面向对象的三大特性

面向对象的三大特性 面向对象的三大特性

• 封装性
• 继承性
• 多态性

1. 封装性

1. 封装性的引入
   有时候在使用一些成品事物的时候，我们往往只需要知道这个东西有什么功能，怎么使用就可以了，不需要细究这个东西内部的原理，这就体现了封装性。例如，有一辆小汽车，我们只需要知道如何驾驶就可以了，没有必要去弄清楚汽车的每个部件是如何组装的，是如何运行的，封装性就是这个道理。

2. 程序设计的“高内聚，低耦合”
   高内聚：类的内部属性 *** 作细节由类自己完成，不允许外部干涉；
   低耦合：仅对外暴露少量类中提供的供外部使用的方法。

3. 隐藏对象内部的复杂性，只对外公开简单的接口。
   通俗的说：隐藏内部 *** 作原理，暴露外部使用方式。这就是封装性的设计思想。

1.1 面向对象封装性

1. 我们创建一个类的对象以后，可以通过"对象.属性"的方式对对象的属性进行赋值。这里，赋值 *** 作只受到属性的数据类型和存储范围的制约，除此之外，没有其他制约条件。但是，实际问题中，我们往往需要给属性赋值加入额外限制条件。这个条件就不能在属性声明时体现，我们只能通过方法进行条件的添加。比如说，属性的getter和setter方法， 同时，我们需要避免用户再使用“对象.属性”的方式对属性进行赋值，则需要将属性声明为私有的(private)。上述，针对于属性就体现了封装性。
2. 封装性的体现：
   我们将类的属性私有化(private),同时,提供公共的(public)方法来获取(getXxx)和设置(setXxx)
3. 拓展：封装性的体现：
   3.1 属性私有化，提供公有的getter和setter方法
   3.2 单例模式，私有化构造函数
   3.3 不对外暴露的私有方法

1.2 四种权限修饰符的理解

1. Java 权限修饰符public、default(缺省)、protected、private置于类的成员定义前，用来限定对象对该类成员的访问权限。
   | 修饰符 | 类内部 | 同一个包 | 不同包的子类 | 同一个工程|
   |–|--|–|--|–|
   | private| Yes | | | |
   | 缺省| Yes | Yes | | |
   | protected| Yes | Yes|Yes | |
   | public| Yes | Yes |Yes | Yes |

2. Java 规定的 4 种权限：(从小到大排序)private、缺省、protected、public

总结

• 权限修饰符可以修饰：属性、方法、构造器、内部类；没有代码块哦，代码块只能使用static修饰
• class只能使用public和缺省修饰；
• Java 提供了 4 中权限修饰符来修饰类及类的内部结构，体现类及类的内部结构的可见性的方法。

2. 继承性

1. 继承性的使用和理解
   通俗的理解，儿子可以继承父亲的资产。类比到Java程序中，子类继承父类的属性和方法。
2. 为什么要有继承性？
   多个类中存在相同属性和行为时，将这些内容抽取到单独一个类中，那些类无需再定义这些属性和行为，只需要继承那个类即可。
3. 继承性的好处
   ① 减少了代码的冗余，提高了代码的复用性；
   ② 便于功能的扩展；
   ③ 为之后多态性的使用，提供了前提
4. 继承性的格式

	class A extends B{ }
 	A : 子类、派生类、subclass
	B : 父类、超类、基类、superclass

• 体现：一旦子类 A 继承父类以后，子类 A 中就获取了父类 B 中声明的结构：属性、方法
  特别的，父类中声明为 private 的属性或方法，子类继承父类以后，仍然认为获取了父类中私有的结构。 只有因为封装性的影响，使得子类不能直接调用父类的结构而已。
• 子类继承父类以后，还可以声明自己特有的属性或方法，实现功能的拓展。
• 子类不能直接访问父类私有 *** 作，但可以通过父类非private的方法来 *** 作父类的私有属性和方法。

5. Java 中关于继承性的规定：
   5.1 一个类可以被多个类继承，但一个类只能继承一个父类
   5.2 子类直接继承的父类，称为：直接父类。间接继承的父类，称为，间接父类。
   5.3 子类继承父类后，就获取了直接父类以及所有间接父类中声明的属性和方法。

6. 如果我们没有显式的声明一个类的父类的话，则此类继承于 java.lang.Object 类。所有的 java 类(除 java.long.Object 类之外)都直接或间接地继承于 java.lang.Object 类;所有的 java 类具有 java.lang.Object 类声明的功能。

7. 方法的重写(override/overwrite)
   7.1 重写：子类继承父类以后，可以对父类中的方法进行覆盖 *** 作。
   7.2 应用：重写以后，当创建子类对象以后，通过子类对象去调用子父类中同名同参数方法时，执行的是子类重写父类的方法。即在程序执行时，子类的方法将覆盖父类的方法。

8. 重写的规定：

 方法的声明：权限修饰符 返回值类型 方法名(形参列表){
 					//方法体
 }
约定俗称:子类中的叫重写的方法，父类中的叫被重写的方法。
	① 子类重写的方法的方法名和形参列表必须和父类被重写的方法的方法名、形参列表相同; 
	② 子类重写的方法使用的访问权限不能小于父类被重写的方法的访问权限,
 	  特殊情况: 子类不能重写父类中声明为private权限的方法;
	③ 返回值类型:
  		> 父类被重写的方法的返回值类型是void,则子类重写的方法的返回值类型只能是void;
  		> 父类被重写的方法的返回值类型是A类型，则子类重写的方法的返回值类型可以是A类或A类的子类;
  		> 父类被重写的方法的返回值类型如果是基本数据类型(比如:double)，则子类重写的方法的返回值类型必须是相同的基本数据类型(必须是:double)。
	④ 子类方法抛出的异常不能大于父类被重写的方法抛出的异常;
	 
注意：子类与父类中同名同参数的方法都必须同时声明为非static的(即为重写)，或者都同时声明为static的（不是重写）。
 	  因为static方法是属于类的，子类无法覆盖父类的方法。

面试题：区分方法的重载与重写(有的书也叫做“覆盖”)
答：

• 方法的重写Overriding和重载Overloading是Java多态性的不同表现。
• 重写Overriding是父类与子类之间多态性的一种表现，重载Overloading是一个类中多态性的一种表现。
• 如果在子类中定义某方法与其父类有相同的名称和参数，我们说该方法被重写 (Overriding)。
• 子类的对象使用这个方法时，将调用子类中的定义，对它而言，父类中的定义如同被"屏蔽"了。
• 如果在一个类中定义了多个同名的方法，它们或有不同的参数个数或有不同的参数类型，则称为方法的重载(Overloading)。

3. 多态性

1. 理解多态性:可以理解为一个事物的多种态性。
2. 何为多态性:
   对象的多态性:父类的引用指向子类的对象(或子类的对象赋值给父类的引用)
3. 多态的使用：虚拟方法调用
   有了对象多态性以后，我们在编译期，只能调用父类声明的方法，但在执行期实际执行的是子类重写父类的方法；
   简称：编译时，看左边；运行时，看右边。
   若编译时类型和运行时类型不一致，就出现了对象的多态性(Polymorphism)
4. 多态情况下：
   “看左边”：看的是父类的引用（父类中不具备子类特有的方法）
   “看右边”：看的是子类的对象（实际运行的是子类重写父类的方法）
5. 多态性的使用前提：
   ① 类的继承关系
   ② 方法的重写
6. 对象的多态性:只适用于方法，不适用于属性(编译和运行都看左边)
7. 从编译和运行的角度看：
   重载，是指允许存在多个同名方法，而这些方法的参数不同。编译器根据方法不同的参数表，对同名方法的名称做修饰。对于编译器而言，这些同名方法就成了不同的方法。它们的调用地址在编译期就绑定了。Java的重载是可以包括父类和子类， 即子类可以重载父类的同名不同参数的方法。所以：对于重载而言，在方法调用之前，编译器就已经确定了所要调用的方法，这称为“早绑定”或“静态绑定”；
   而对于多态，只有等到方法调用的那一刻，解释运行器才会确定所要调用的具体方法，这称为“晚绑定”或“动态绑定”。

3.1 向下转型