下载文档原格式
⾯向对象知识点总结1、⾯向对象三⼤特征封装：封装就是隐藏对象的属性和实现细节，仅对外公开接⼝，控制在程序中属性的读和修改的访问级别，将抽象得到的数据和⾏为（或功能）相结合，形成⼀个有机的整体。
继承：继承就是⼦类继承⽗类的特征和⾏为，使得⼦类对象（实例）具有⽗类的实例域和⽅法，或⼦类从⽗类继承⽅法，使得⼦类具有⽗类相同的⾏为。
多态：多态指同⼀个⾏为具有多个不同表现形式或形态的能⼒，是指⼀个类实例（对象）的相同⽅法在不同情形有不同表现形式，使具有不同内部结构的对象可以共享相同的外部接⼝。
2、类与对象对象：对象是类的⼀个实例，有状态和⾏为。
类：类是⼀个模板，它描述⼀类对象的⾏为和状态。
⼀个类可以包含以下类型变量：（1）局部变量：在⽅法、构造⽅法或者语句块中定义的变量被称为局部变量。
变量声明和初始化都是在⽅法中，⽅法结束后，变量就会⾃动销毁。
（2）成员变量：成员变量是定义在类中，⽅法体之外的变量。
这种变量在创建对象的时候实例化。
成员变量可以被类中⽅法、构造⽅法和特定类的语句块访问。
（3）类变量：类变量也声明在类中，⽅法体之外，但必须声明为 static 类型。
3、构造⽅法每个类都有构造⽅法。
如果没有显式地为类定义构造⽅法，Java 编译器将会为该类提供⼀个默认构造⽅法。
在创建⼀个对象的时候，⾄少要调⽤⼀个构造⽅法。
构造⽅法的名称必须与类同名，⼀个类可以有多个构造⽅法。
4、封装封装是指⼀种将抽象性函式接⼝的实现细节部分包装、隐藏起来的⽅法。
封装可以被认为是⼀个保护屏障，防⽌该类的代码和数据被外部类定义的代码随机访问。
要访问该类的代码和数据，必须通过严格的接⼝控制。
修改属性的可见性来限制对属性的访问（⼀般限制为private），可通过getter和setter⽅法访问和操作类中私有成员变量。
如下代码：class BookClass{private String title;private int pageNum;BookClass(){};// 设置名称public void setTille(String title) {this.title = title;}public String getTitle() {return title;}// 设置页数public void setPageNum(int pageNum) {if (pageNum>=200) {this.pageNum = pageNum;} else {System.out.println("页数输⼊错误，图书页数不能⼩于200页，设置为默认值200");this.pageNum = 200;}}public int getPageNum() {return pageNum;}// 显⽰图书信息public void detail() {System.out.println("图书名称为："+title+"，页数为："+pageNum);}}5、继承在 Java 中通过 extends 关键字可以申明⼀个类是从另外⼀个类继承⽽来的。
C++中的封装、继承、多态理解封装(encapsulation)：就是将抽象得到的数据和⾏为(或功能)相结合，形成⼀个有机的整体，也就是将数据与操作数据的源代码进⾏有机的结合，形成”类”，其中数据和函数都是类的成员。
封装的⽬的是增强安全性和简化编程，使⽤者不必了解具体的实现细节，⽽只是要通过外部接⼝，特定的访问权限来使⽤类的成员。
封装可以隐藏实现细节，使得代码模块化。
继承(inheritance)：C++通过类派⽣机制来⽀持继承。
被继承的类型称为基类或超类，新产⽣的类为派⽣类或⼦类。
保持已有类的特性⽽构造新类的过程称为继承。
在已有类的基础上新增⾃⼰的特性⽽产⽣新类的过程称为派⽣。
继承和派⽣的⽬的是保持已有类的特性并构造新类。
继承的⽬的：实现代码重⽤。
派⽣的⽬的：实现代码扩充。
三种继承⽅式：public、protected、private。
继承时的构造函数：(1)、基类的构造函数不能被继承，派⽣类中需要声明⾃⼰的构造函数；(2)、声明构造函数时，只需要对本类中新增成员进⾏初始化，对继承来的基类成员的初始化，⾃动调⽤基类构造函数完成；(3)、派⽣类的构造函数需要给基类的构造函数传递参数；(4)、单⼀继承时的构造函数：派⽣类名::派⽣类名(基类所需的形参，本类成员所需的形参):基类名(参数表) {本类成员初始化赋值语句；}；(5)、当基类中声明有默认形式的构造函数或未声明构造函数时，派⽣类构造函数可以不向基类构造函数传递参数；(6)、若基类中未声明构造函数，派⽣类中也可以不声明，全采⽤缺省形式构造函数；(7)、当基类声明有带形参的构造函数时，派⽣类也应声明带形参的构造函数，并将参数传递给基类构造函数；(8)、构造函数的调⽤次序：A、调⽤基类构造函数，调⽤顺序按照它们被继承时声明的顺序(从左向右)；B、调⽤成员对象的构造函数，调⽤顺序按照它们在类中的声明的顺序；C、派⽣类的构造函数体中的内容。
继承时的析构函数：(1)、析构函数也不被继承，派⽣类⾃⾏声明；(2)、声明⽅法与⼀般(⽆继承关系时)类的析构函数相同；(3)、不需要显⽰地调⽤基类的析构函数，系统会⾃动隐式调⽤；(4)、析构函数的调⽤次序与构造函数相反。
简述对面向对象的三大特征的理解
面向对象有三大特点：封装、继承、多态。
1、继承性：
继承是一种联结类的层次模型，并且允许和鼓励类的重用，它提供了一种明确表述共性的方法。
对象的一个新类可以从现有的类中派生，这个过程称为类继承。
新类继承了原始类的特性，新类称为原始类的派生类（子类），而原始类称为新类的基类（父类）。
派生类可以从它的基类那里继承方法和实例变量，并且类可以修改或增加新的方法使之更适合特殊的需要。
2、封装性：
封装是把过程和数据包围起来，对数据的访问只能通过已定义的界面。
面向对象计算始于这个基本概念，即现实世界可以被描绘成一系列完全自治、封装的对象，这些对象通过一个受保护的接口访问其他对象。
3、多态性：
多态性是指允许不同类的对象对同一消息作出响应。
多态性包括参数化多态性和包含多态性。
多态性语言具有灵活、抽象、行为共享、代码共享的优势，很好的解决了应用程序函数同名问题。
一丶封装1 权限修饰符可以用来修饰成员变量和成员方法，对于类的权限修饰只可以用public和缺省default。
被public修饰的类可以在任意地方被访问；default类只可以被同一个包内部的类访问。
权限由大到小：public protected default(不写) private被private修饰的成员只能在本类中访问，外界不能访问2 set()/get()方法（1）this关键字a.可以用来调用变量，方法，构造方法；b.this.xx 理解为调用当前类的xx。
（2）成员变量和局部变量1）在类中的位置不同a:成员变量:在类中,方法外b:局部变量:在方法声明上（形式参数）,或者是在方法定义中2）在内存中的位置不同a:成员变量:在堆内存b:局部变量:在栈内存3）生命周期不同a:成员变量:随着对象的创建而存在,随着对象的消失而消失b:局部变量:随着方法调用而存在,随着方法的调用结束而消失4）初始化值不同a:成员变量:有默认值b:局部变量:必须初始化值,否则报错!(在使用它之前,没有初始化) （3）set()/get()方法当成员变量被private修饰时，不在本类中无法直接访问，便需要set()/get()方法来解决这个问题3 封装性封装：是面向对象的第一大特性，所谓封装，就是值对外部不可见（一般而言被private修饰），外部只能通过对象提供的接口（如set()/get()方法）来访问。
封装的好处：a.良好的封装能够减少耦合；b.类内部的结构可以自己修改，对外部影响不大；c.可以对成员进行更精准的控制（防止出现与事实不符的情况）；d.影藏实现细节。
注意：在开发中，类的成员变量全部要进行封装，封装之后通过set()/get()方法访问。
二丶继承extends1 实现：通过 class Zi extends Fu{} 实现类的继承（1）子类继承父类，父类中声明的属性，方法，子类都可以获取到；当父类中有私有的属性方法时，子类同样可以获取到，由于封装性的设计，使得子类不能直接调用访问。
2、C#⾯向对象：封装、继承、多态、String、集合、⽂件（上）⾯向对象封装⾯向对象概念⼀、⾯向对象概念⾯向过程：⾯向的是完成⼀件事情的过程，强调的是完成这件事情的动作。
⾯向对象：找个对象帮你完成这件事情。
⼆、⾯向对象封装把⽅法进⾏封装，隐藏实现细节，外部直接调⽤。
打包，便于管理，为了解决⼤型项⽬的维护与管理。
三、什么是类？将相同的属性和相同⽅法的对象进⾏封装，抽象出 “类”，⽤来确定对象具有的属性和⽅法。
类、对象关系：⼈是类，张三是⼈类的对象。
类是抽象的，对象是具体的。
对象可以叫做类的实例，类是不站内存的，对象才占内存。
字段是类的状态，⽅法是类执⾏的动作。
三个特性：封装、继承、多态。
四、访问修饰符public 公共的，任何地⽅都可以访问private 私有的，只有本类中成员可以访问protected 受保护的，可以在当前类以及⼦类访问Intelnal 只能在当前项⽬中访问，在同⼀个项⽬中Intelnal和public权限是⼀样的。
protected Intelnal 当前项⽬受保护的。
修饰类的访问修饰符只有两个：public、Intelnal定义⼀个类时，如果不加访问修饰符，默认是Intelnal可访问性不⼀致：⼦类可访问性不能⾼于⽗类可访问性，可能会被暴漏⽗类成员。
类中的成员，如果不加访问修饰符，默认都是private定义⼀个类[public] class 类名{字段；属性；⽅法；}class person{public string name; //字段public int age;public int height;public void sayHi(){Console.WriteLine("Hello , my name is {0}, my age is {1} , my height is {2}" , , this.age,this.height); //this当前类}}使⽤关键字 new 创建类的对象称之为实例化。
面向对象设计的三大原则，理解并能举例
面向对象编程设计有三大原则，分别是封装（Encapsulation）、继承（Inheritance）和多态（Polymorphism）。
1. 封装（Encapsulation）：封装是将数据和相关行为（方法）
组合在一个类中，以实现隐藏内部实现细节的原则。
通过封装，可以将一组数据和对它们的操作封装在一个类中，对外部只暴露必要的接口，隐藏了实现的细节，提高了代码的安全性和可维护性。
例如，一个汽车类可以封装了颜色、品牌、速度等变量和加速、刹车等方法，对外只提供加速和刹车的接口，而隐藏了内部细节。
2. 继承（Inheritance）：继承是指创建一个新类（子类）从已
有的类（父类）中继承属性和方法的过程。
子类可以通过继承父类的特性来扩展和增强功能，并且可以重用已有的代码。
例如，有一个动物类，定义了一些公共属性和方法，然后创建了狗类和猫类继承动物类，狗类和猫类就可以共享动物类的一些功能，同时可以根据需要添加自己的特定功能。
3. 多态（Polymorphism）：多态是指同一类对象在不同情况下
可以表现出不同的行为。
对象多态性使用继承和接口实现，通过动态绑定和方法重写，允许不同的对象对同一个方法做出不同的响应。
例如，一个动物类中有一个叫声的方法，猫类和狗类都继承了动物类，并重写了叫声的方法，当通过调用叫声方法时，猫和狗的叫声不同，实现了多态性。
这三个原则是面向对象设计的基石，有助于实现代码的可重用性、可扩展性和灵活性。
简述面向对象三大特征的理解
面向对象三大特征的理解：
1、封装：封装是指将实现细节与外部接口分离开来，使外部程序只能通过接口对内部实现不可见，以达到安全隐蔽内部实现，使得调用者不必担心内部实现之细节而单纯地调用，也就是说在使用某个对象时，不需要知道其内部具体实现的细节，只要知道对象具备的功能即可。
2、继承：继承是指多个对象可以从公共父类中继承数据属性和行为，子类之间还可以相互继承，这种继承关系能够让类之间的体系结构更加清晰，减少编码量，提高代码的复用性，使得程序结构更加清晰和有条理。
3、多态：多态是指不同的对象之间可以进行不同操作，也就是说多态是指在同一个消息被传递到不同的对象时，可以采取不同的行为，而且多态的行为可以在运行时动态变化，从而实现更加灵活的程序设计。
- 1 -。
java的封装，继承和多态类和对象类类声明 { 成员变量的声明； 成员方法的声明及实现； }声明类：[修饰符] class 类<泛型> [extends 父类] [implements 接口列表]声明成员变量：[修饰符]数据类型 变量[=表达式]{,变量[=表达式]}成员方法声明：[修饰符]返回值类型 方法（[形式参数列表]）[throws 异常类列表]{语句序列；[return[返回值]]； }重载：一个类中可以有多个同名的成员方法，前提是参数列表不同，称为类的成员方法重载，重载的多个方法为一种功能提供多种实现。
重载方法之间必须以不同的参数列表（数据类型、参数个数、参数次序）来区别。
例如，MyDate 类可声明多个重载的set()方法如下: void set(int y,int m, int d)void set(int m, int d) //重载方法，参数个数不同void set(int d) void set(MyDate date)//重载方法，参数的数据类型不同对象对象声明：类 对象构造实例：对象 = new 类的构造方法（[实际参数列表]）引用对象的成员变量和调用成员方法：对象.成员变量 对象.成员方法([实际参数列表])类的封装性构造与析构类的构造方法用于创建类的一个实例并对实例的成员变量进行初始化一个类可声明多个构造方法对成员变量进行不同需求的初始化，构造方法不需要写返回值类型，因为它返回的就是该类的一个实例。
例：MyDate类声明以下构造方法:public MyDate(int year, int month, int day)// 声明构造方法，方法名同类名，初始化成员变量 {set(year, month day);// 调用 set()方法，为成员变量赋值}使用new运算符调用指定类的构造方法，实际参数列表必须符合构造方法声明。
例如:MyDate d1 = new MyDate(2017,10,1);//创建实例并初始化成员变量当一个类没有声明构造方法时，Java 自动为该类提供一个无参数的默认构造方法对象的引用与运算this引用访问本类的成员变量和成员方法：this.成员变量，this.成员方法([实际参数列表])调用本类重载的构造方法：this([实际参数列表])访问控制类的访问控制权限公有和(public)和缺省类中成员4级访问控制权限及范围声明set()和get()方法存取对象的属性例：public void set(int year, int month, int day) //设置日期值 public void set(MyDate date)//设置日期值，重载 public int getYear()//获得年份 public int getMonth()// 获得月份 public int getDay()//获得当月日期静态成员定义及访问格式使用关键字static声明的成员称为静态成员在类内部，可直接访问静态成员，省略类名。
OOP编程思想：封装、继承、多态⾯向对象编程（Object-Oriented Programming）与⾯向过程（Procedure Oriented ）两种⽅法都是编程中的⽐较常⽤的⽅法，从理论上来说，都能达到⽤计算机程序来解决实际问题的⽬的，只不过是其中所体现出来的思想不⼀样⽽已。
⾯向过程：⾯向过程的思想是把⼀个项⽬、⼀件事情按照⼀定的顺序，从头到尾⼀步⼀步地做下去，先做什么，后做什么，⼀直到结束。
这种思想⽐较好理解，其实这也是⼀个⼈做事的⽅法。
⾯向对象：⾯向对象的思想是把⼀个项⽬、⼀件事情分成更⼩的项⽬，或者说分成⼀个个更⼩的部分，每⼀部分负责什么⽅⾯的功能，最后再由这些部分组合⽽成为⼀个整体。
这种思想⽐较适合多⼈的分⼯合作，就像⼀个⼤的机关，分成各个部门，每个部门分别负责某样职能，各个部门可以充分发挥⾃⼰的特⾊，只要符合⼀定前提就⾏了。
⾯向对象（OOP）的三个特征：封装（Encapsulation）继承（Inheritance）多态（Polymorphism）⼀、封装1、定义：Encapsulation in Java is a mechanism of wrapping the data (variables) and code acting on the data (methods) together as a single unit. In encapsulation, the variables of a class will be hidden from other classes, and can be accessed only through the methods of their current class. Java中的封装是⼀种将数据(变量)和作⽤于数据(⽅法)的代码打包为⼀个单元的机制。
在封装中，类的变量将对其他类隐藏，并且只能通过当前类的⽅法访问。
Encapsulation can change the internal structure of a class without affecting the overall structure, while protecting the data. For the outside world, its interior is hidden, and what is exposed to the outside world is only the methods that can access it. 封装可以对类的内部进⾏改变⽽不影响整体结构，同时也保护来数据。
