面向对象编程三大特性------封装、继承、多态

1.封装

　　也就是把客观事物封装成抽象的类，并且类可以把自己的数据和方法只让可信的类或者对象操作，对不可信的进行信息隐藏。封装是面向对象的特征之一，是对象和类概念的主要特性。 简单的说，一个类就是一个封装了数据以及操作这些数据的代码的逻辑实体。在一个对象内部，某些代码或某些数据可以是私有的，不能被外界访问。通过这种方式，对象对内部数据提供了不同级别的保护，以防止程序中无关的部分意外的改变或错误的使用了对象的私有部分。

1、良好的封装能够减少耦合。

2、类内部的结构可以自由修改（模块化）。

3、增加代码的复用性。

4、隐藏信息，实现细节（隐藏实现细节）。

5、安全性

2. 继承：

　　是指可以让某个类型的对象获得另一个类型的对象的属性的方法。它支持按级分类的概念。继承是指这样一种能力：它可以使用现有类的所有功能，并在无需重新编写原来的类的情况下对这些功能进行扩展。 通过继承创建的新类称为“子类”或“派生类”，被继承的类称为“基类”、“父类”或“超类”。继承的过程，就是从一般到特殊的过程。要实现继承，可以通过“继承”（Inheritance）和“组合”（Composition）来实现。继承概念的实现方式有二类：实现继承与接口继承。实现继承是指直接使用基类的属性和方法而无需额外编码的能力；接口继承是指仅使用属性和方法的名称、但是子类必须提供实现的能力（即之类必须重写父类所有方法）。

1、子类拥有父类非private的属性和方法。

2、子类可以拥有自己属性和方法，即子类可以对父类进行扩展。

3、子类可以用自己的方式实现父类的方法。

继承的好处：

（1）：继承是传递的，容易在其基础上构造，建立和扩充出新的类。

（2）：简化了人们对事物的认识和描述，能清晰体现相关类之间的层次结构关系。

（3）：能减少数据和代码的冗余度。

（4）：大大增加了代码的维护性。

3.1多态：

　　1、多态：同一操作作用于不同的对象，可以有不同的解释，产生不同的执行结果。在运行时，可以通过指向基类的指针，来调用实现派生类中的方法。

　　编译时的多态性：

　　编译时的多态性是通过重载来实现的。对于非虚的成员来说，系统在编译时，根据传递的参数、返回的类型等信息决定实现何种操作。 

　　运行时的多态性：

　　运行时的多态性就是指直到系统运行时，才根据实际情况决定实现何种操作。C#中，运行时的多态性通过虚成员实现。 

　　编译时的多态性为我们提供了运行速度快的特点，而运行时的多态性则带来了高度灵活和抽象的特点。

 　　2、实现多态：

1. 接口多态性。
2. 继承多态性。
3. 通过抽象类实现的多态性。

　　3、override关键字：

　　　重写父类中的virtual修饰的方法，实现多态。

关于多态的很值的一看的一个案列：https://blog.csdn.net/jianyuerensheng/article/details/51602015

3.2 实现形式

   在Java中有两种形式可以实现多态：继承和接口。

3.2.1、基于继承实现的多态

    基于继承的实现机制主要表现在父类和继承该父类的一个或多个子类对某些方法的重写，多个子类对同一方法的重写可以表现出不同的行为。

    基于继承实现的多态可以总结如下：对于引用子类的父类类型，在处理该引用时，它适用于继承该父类的所有子类，子类对象的不同，对方法的实现也就不同，执行相同动作产生的行为也就不同。

    如果父类是抽象类，那么子类必须要实现父类中所有的抽象方法，这样该父类所有的子类一定存在统一的对外接口，但其内部的具体实现可以各异。这样我们就可以使用顶层类提供的统一接口来处理该层次的方法。

3.2.2、基于接口实现的多态

    继承是通过重写父类的同一方法的几个不同子类来体现的，那么就可就是通过实现接口并覆盖接口中同一方法的几不同的类体现的。

    在接口的多态中，指向接口的引用必须是指定这实现了该接口的一个类的实例程序，在运行时，根据对象引用的实际类型来执行对应的方法。

    继承都是单继承，只能为一组相关的类提供一致的服务接口。但是接口可以是多继承多实现，它能够利用一组相关或者不相关的接口进行组合与扩充，能够对外提供一致的服务接口。所以它相对于继承来说有更好的灵活性。

3.2.3、经典实例分析

 1 public class A {  
 2     public String show(D obj) {  
 3         return ("A and D");  
 4     }  
 5   
 6     public String show(A obj) {  
 7         return ("A and A");  
 8     }   
 9   
10 }  
11   
12 public class B extends A{  
13     public String show(B obj){  
14         return ("B and B");  
15     }  
16       
17     public String show(A obj){  
18         return ("B and A");  
19     }   
20 }  
21   
22 public class C extends B{  
23   
24 }  
25   
26 public class D extends B{  
27   
28 }  
29   
30 public class Test {  
31     public static void main(String[] args) {  
32         A a1 = new A();  
33         A a2 = new B();  
34         B b = new B();  
35         C c = new C();  
36         D d = new D();  
37           
38         System.out.println("1--" + a1.show(b));  
39         System.out.println("2--" + a1.show(c));  
40         System.out.println("3--" + a1.show(d));  
41         System.out.println("4--" + a2.show(b));  
42         System.out.println("5--" + a2.show(c));  
43         System.out.println("6--" + a2.show(d));  
44         System.out.println("7--" + b.show(b));  
45         System.out.println("8--" + b.show(c));  
46         System.out.println("9--" + b.show(d));        
47     }  
48 }  

运行结果：

分析如下：

①②③比较好理解，一般不会出错。④⑤就有点糊涂了，为什么输出的不是"B and B”呢？

    当超类对象引用变量引用子类对象时，被引用对象的类型而不是引用变量的类型决定了调用谁的成员方法，但是这个被调用的方法必须是在超类中定义过的，也就是说被子类覆盖的方法。（但是如果强制把超类转换成子类的话，就可以调用子类中新添加而超类没有的方法了。）

在继承链中对象方法的调用存在一个优先级：this.show(O)、super.show(O)、this.show((super)O)、super.show((super)O)。

上面程序中的A,B,C,D存在如下关系：

分析4：

    a2.show(b)，a2是一个引用变量，类型为A，则this为a2，b是B的一个实例，于是它到类A里面找show(B obj)方法，没有找到，于是到A的super(超类)找，而A没有超类，因此转到第三优先级this.show((super)O)，this仍然是a2，这里O为B，(super)O即(super)B即A，因此它到类A里面找show(A obj)的方法，类A有这个方法，但是由于a2引用的是类B的一个对象，B覆盖了A的show(A obj)方法，因此最终锁定到类B的show(A obj)，输出为"B and A”。

分析5：

    a2.show(c)，a2是A类型的引用变量，所以this就代表了A，a2.show(c),它在A类中找发现没有找到，于是到A的超类中找(super)，由于A没有超类（Object除外），所以跳到第三级，也就是this.show((super)O)，C的超类有B、A，所以(super)O为B、A，this同样是A，这里在A中找到了show(A obj)，同时由于a2是B类的一个引用且B类重写了show(A obj)，因此最终会调用子类B类的show(A obj)方法，结果也就是B and A。

分析8：

    b.show(c)，b是一个引用变量，类型为B，则this为b，c是C的一个实例，于是它到类B找show(C obj)方法，没有找到，转而到B的超类A里面找，A里面也没有，因此也转到第三优先级this.show((super)O)，this为b，O为C，(super)O即(super)C即B，因此它到B里面找show(B obj)方法，找到了，由于b引用的是类B的一个对象，因此直接锁定到类B的show(B obj)，输出为"B and B”。

    按照同样的方法我也可以确认其他的答案。

   当超类对象引用变量引用子类对象时，被引用对象的类型而不是引用变量的类型决定了调用谁的成员方法，但是这个被调用的方法必须是在超类中定义过的，也就是说被子类覆盖的方法。这我们用一个例子来说明这句话所代表的含义：a2.show(b)；

    这里a2是引用变量，为A类型，它引用的是B对象，因此按照上面那句话的意思是说有B来决定调用谁的方法,所以a2.show(b)应该要调用B中的show(B obj)，产生的结果应该是“B and B”，但是为什么会与前面的运行结果产生差异呢？这里我们忽略了后面那句话“被调用的方法必须是在超类中定义过的”，那么show(B obj)在A类中存在吗？根本就不存在！所以这句话在这里不适用？那么难道是这句话错误了？非也！其实这句话还隐含这这句话：它仍然要按照继承链中调用方法的优先级来确认。所以它才会在A类中找到show(A obj)，同时由于B重写了该方法所以才会调用B类中的方法，否则就会调用A类中的方法。

4. 关于构造方法

如果父类中已经构建过无参方法，子类不需要重新构建，也就是说必须有一个继承类中有无参构造方法。
如果父类中没有此构造方法，那么必须在子类中进行无参构造，否则子类会一直提示需要重写父类方法。
备注：这个建议根据java规范，每次创建类（需要构建）的时候就构建一个无参的构造方法，肯定不会报错。

参考文章：https://blog.csdn.net/hs2201056/article/details/61461751
　　　　　https://blog.csdn.net/jianyuerensheng/article/details/51602015
　　　　　https://www.cnblogs.com/1711643472qq/p/5909839.html