类的继承和多态细思
一、前言
类的继承和多态光靠概念和想象是不够的，我们需要编码去分析之，因此我使用代码来说明一些很难分清的东西。
二、分析代码
A类代码：
package zyr.study.poly; public class A { public A(){ System.out.println("初始化A..."); } public String show(A obj) { return ("A and A"); } public String show(B obj) { return ("A and B"); } public String show(D obj) { return ("A and D"); } }
B类代码：
package zyr.study.poly; public class B extends A{ public B(){ System.out.println("初始化B..."); } public String show(A obj){ return ("B and A"); } public String show(B obj){ return ("B and B"); } }
C类代码：
package zyr.study.poly; public class C extends B{ public C(){ System.out.println("初始化C..."); } }
D类代码：
package zyr.study.poly; public class D extends B{ public D(){ System.out.println("初始化D..."); } }
main函数：
1 package zyr.study.poly; 2 3 4 public class Main { 5 6 public static void main(String[] args) { 7 A a1 = new A(); 8 System.out.println("-----------------"); 9 A a2 = new B(); 10 System.out.println("-----------------"); 11 B b = new B(); 12 System.out.println("-----------------"); 13 C c = new C(); 14 System.out.println("-----------------"); 15 D d = new D(); 16 System.out.println("-----------------"); 17 18 System.out.println("1--" + a1.show(a1)); // a and a 19 System.out.println("2--" + a1.show(a2)); // a and a 20 System.out.println("3--" + a1.show(b)); // a and b 21 System.out.println("4--" + a1.show(c)); // a and b 22 System.out.println("5--" + a1.show(d)); // a and d 23 24 System.out.println("-----------------"); 25 26 System.out.println("1--" + a2.show(a1)); // b and a 27 System.out.println("2--" + a2.show(a2)); // b and a 28 System.out.println("3--" + a2.show(b)); // b and b 29 System.out.println("4--" + a2.show(c)); // b and b 30 System.out.println("5--" + a2.show(d)); // a and d 31 32 System.out.println("-----------------"); 33 34 System.out.println("1--" + b.show(a1)); // b and a 35 System.out.println("2--" + b.show(a2)); // b and a 36 System.out.println("3--" + b.show(b)); // b and b 37 System.out.println("4--" + b.show(c)); // b and b 38 System.out.println("5--" + b.show(d)); // a and d 39 } 40 }
运行结果：
初始化A... ----------------- 初始化A... 初始化B... ----------------- 初始化A... 初始化B... ----------------- 初始化A... 初始化B... 初始化C... ----------------- 初始化A... 初始化B... 初始化D... ----------------- 1--A and A 2--A and A 3--A and B 4--A and B 5--A and D ----------------- 1--B and A 2--B and A 3--B and B 4--B and B 5--A and D ----------------- 1--B and A 2--B and A 3--B and B 4--B and B 5--A and D
下面我们仔细分析这个程序和运行结果。
首先我们定义了一个类，命名为A，这是一个超类或者叫做基类。在这个类中，使用了函数级别的多态或者说是重载，分别能识别的类型为A类、B类（A类的子类），D类（B类的子类，A类的孙类）；
然后我们定义了B类，继承自A类，同时重写了A类和B类；
之后我们定义了C类，继承自B类，无操作；
然后我们定义了D类，继承自B类，无操作；
在函数体中，我们使用了各自的类定义了对象，并且有一个特殊的，那就是A类的引用指向了B类的对象，这就是多态了，这样的结果就是，A a2=new B();a2所指的函数中因为B继承自A，除了B中重写A中的方法之外，B中其他的方法都是不可见的，并且A中除了被重写的方法之外的方法是可见的。
让我们看第一批分析：
1 System.out.println("1--" + a1.show(a1)); // a and a 2 System.out.println("2--" + a1.show(a2)); // a and a 3 System.out.println("3--" + a1.show(b)); // a and b 4 System.out.println("4--" + a1.show(c)); // a and b 5 System.out.println("5--" + a1.show(d)); // a and d
对于第一行，a1的定义是A类的引用，并且指向A的对象，因此可见范围为A类中的A,B,D，因此，只有在A中的方法才能被选择，所以本身作为参数A，则选A and A;对于第二行，a2的定义还是A类的，只不过包含的东西多了一点而已（其实也不多，只是包含了B中重写A中的方法，而不包含A中被重写的方法），因此底子里还是A类的，只会认A，结果为A and A；对于第三行，b是货真价实的，则选择A and B；对于第四行，C的对象就看关系的远近了，在符合条件的所有方法中，找一个距离C血缘关系最近的类，那就是B类了，因为A中没有C类的方法，因此A and B；对于第五行，A中正好有D类的方法，因此血缘关系肯定是最近了，选择自身A and D。
再来看第二批函数：
1 System.out.println("1--" + a2.show(a1)); // b and a 2 System.out.println("2--" + a2.show(a2)); // b and a 3 System.out.println("3--" + a2.show(b)); // b and b 4 System.out.println("4--" + a2.show(c)); // b and b 5 System.out.println("5--" + a2.show(d)); // a and d
首先，a2是个变态，经过了一定的改变，按照上面的分析，我们知道此时函数的可见性是A and D;B and A;B and B;
因此第一行，找距离A类血缘最近的，肯定是B and A了；第二行，a2本质上还是A的引用，因此依旧是B and A；第三行，B找到自己血缘关系最近的B and B;第四行，C依旧寻找距离自己关系最近的，B and B;第五行，D寻找到了A and D；
最后看看第三批函数：
1 System.out.println("1--" + b.show(a1)); // b and a 2 System.out.println("2--" + b.show(a2)); // b and a 3 System.out.println("3--" + b.show(b)); // b and b 4 System.out.println("4--" + b.show(c)); // b and b 5 System.out.println("5--" + b.show(d)); // a and d
可见性：B是货真价实的，因此A and D;B and A;B and B。对于第一行，A类血缘最近的是B and A;第二行，a2也是A,因此B and A;第三行，b选择B and B;第四行，C选择血缘最近的B and B;第五行，D选择A and D。
下面我们将B类里面加入一个C的函数，其他的不变，可见性会发生改变，我们分析一下结果：
1 package zyr.study.poly; 2 3 public class B extends A{ 4 public B(){ 5 System.out.println("初始化B..."); 6 } 7 8 public String show(A obj){ 9 return ("B and A"); 10 } 11 12 public String show(B obj){ 13 return ("B and B"); 14 } 15 16 public String show(C obj){ 17 return ("B and C"); 18 } 19 }
对于第一批函数，因为可见性的原因，B的修改不能影响结果；对于第二批函数，多了一个C函数，可是我们知道多态的性质，a2所指的函数中C函数依旧是不可见的，因此不影响最终结果。对于第三批函数，可见性也发生了改变，在原有基础上多了C函数，因此第三批第四行中结果变成B and C，这从侧面上证明我们的分析是正确的。
运行结果如下：
初始化A... ----------------- 初始化A... 初始化B... ----------------- 初始化A... 初始化B... ----------------- 初始化A... 初始化B... 初始化C... ----------------- 初始化A... 初始化B... 初始化D... ----------------- 1--A and A 2--A and A 3--A and B 4--A and B 5--A and D ----------------- 1--B and A 2--B and A 3--B and B 4--B and B 5--A and D ----------------- 1--B and A 2--B and A 3--B and B 4--B and C 5--A and D
对于构造函数的初始化，我们可以看到都是先初始化最超类，然后次超类，一直到自身的，如果将超类的构造函数设为私有，将提示错误，否则没问题。
三、总结
在编程中，我们要注意定义中引用所指对象的可见性，先分析可见性，分析的时候要注意重载（override）和重写（overwrite）的区别，重写就是覆盖，重载有可能被排除在外，一定要记得。还有函数的初始化以及变量的可见性，都是值得分析的，如果再加上静态变量，静态函数，一切都变得有意思了。