我们知道，面向对象三大特性里，封装、继承和多态里，多态是最复杂的。
多态的实现方式分为接口、重写Override和重载Overload：
接口不用说了。
重写Override是在父子类之间有相同的方法和参数，是父子类的多态性。
重载Overload是一个类内部有同名方法但是参数不同，是一个类的多态性。（重载在编译期就能确定使用了那个函数，所以不是运行时多态，有些学派因此认为重载不算正宗的多态）
这里面，重写是一个难点，特别它的多态性是在运行时表现出来的，容易绕晕，一般来讲，重写多态是这样的：
A a=new B();
a叫做引用变量，引用变量指向的具体类型和方法，在编译时不能确定，是在运行时确定的。
重写在多态上的表现就是具体指向哪个重写方法：
首先，超类（A）中需要定义这个方法。
然后，引用对象（B）中定义了这个方法的最终形态；
多态重写有三个必要条件：
1.继承
2.重写
3.父类引用指向子类对象
我们先看规律，再根据两个经典例题来掌握规律的用法。
几个规律
左右
变量多态看左边，
静态多态看左边，
方法多态看右边（左边的方法表里需要有这个方法）。
优先级
假设有个show(Object obj)函数，那么对于show函数所在的类及其父类，已经参数Object来说，有固定的优先级（JVM虚拟机里的方法表查询机制，决定了这个优先级）：
this.show(O)>>super.show(O)>>this.show(super(O))>>super.show(super(O))，这是虚拟机多态的机制里定义的优先级，具体意思是说：
优先使用当前类的定义this.show(O)
次优先使用父类的定义super.show(O)
第三位使用当前类定义的父类参数函数this.show(super(O))
最后使用父类定义的父类参数函数super.show(super(O))
例题1
public class A{
void a(){
System.out.print("Aa");
}
void b(){
System.out.print("Ab");
}
}
public class B extends A{
void b(){
System.out.print("Bb");
}
void d(){
System.out.print("Bd");
}
}
private void doTest(){
A a=new B();
a.a(); //Aa 只有A有实现，不需要多态
a.b(); //Bb 在子类B有实现，多态
a.d(); //A的方法表中没有d，编译错误
B b=(B)a; //可以强转
b.a(); //Aa B没有实现，向父类A中寻找，并找到
b.b(); //Bb B类的方法
b.d(); //Bd B类的方法
}
例题2
class A{
public String show(D obj){
return ("AD");
}
public String show(A obj){
return ("AA");
}
}
class B extends A{
public String show(B obj){
return ("BB");
}
public String show(A obj){
return ("BA");
}
}
class C extends B{}
class D extends B{}
//调用
A a1 = new A();
A a2 = new B();
B b = new B();
C c = new C();
D d = new D();
//其实就是考察从父类/参数多态的优先级：this.show(O)>>super.show(O)>>this.show(super(O))>>super.show(super(O))
System.out.println(a1.show(b)); // ① AA，因为参数B是A，优先级为this.show(super(O))
//相当于this.show(O)>>super.show(O)>>this.show(super(O)) 这里 >>super.show(super(O))
System.out.println(a1.show(c)); // ② AA，同上
System.out.println(a1.show(d)); // ③ AD，因为A定义了show(D obj)，优先级为this.show(O)
//相当于this.show(O)这里>>super.show(O)>>this.show(super(O)) >>super.show(super(O))
System.out.println(a2.show(b)); // ④ BA，因为A没定义show(B obj)，只能找到show(A obj)，还是优先级为this.show(super(O))
//相当于this.show(O)>>super.show(O)>>this.show(super(O)) 这里>>super.show(super(O))
System.out.println(a2.show(c)); // ⑤ AA，同上
System.out.println(a2.show(d)); // ⑥ AD，因为A定义了show(D obj)，优先级为this.show(O)
//相当于this.show(O)这里>>super.show(O)>>this.show(super(O)) >>super.show(super(O))
System.out.println(b.show(b)); // ⑦ BB，因为B定义了show(B obj)，优先级为this.show(O)
//相当于this.show(O)这里>>super.show(O)>>this.show(super(O)) >>super.show(super(O))
System.out.println(b.show(c)); // ⑧ BB，因为B定义了show(B obj)，优先级为this.show(super(O))
//相当于this.show(O)>>super.show(O)>>this.show(super(O)) 这里>>super.show(super(O))
System.out.println(b.show(d)); // ⑨ AD，因为A定义了show(D obj)，优先级为super.show(O)
//相当于this.show(O)>>super.show(O)这里>>this.show(super(O)) >>super.show(super(O))
总结
对于A a=new B();这种形式的多态，B是A的子类，那么调用a.func(D obj)时，需要注意这样几个问题：
1.func函数在A未定义、在B定义。会编译错误，因为a的函数仅限于A定义过的，B的函数在a中不能访问
2.func函数在A、B都有定义。这时应采用B的实现。
3.func函数在A定义，在B未定义。这时会采用A的实现。
4.func函数在A、B均未定义。会编译错误。
5.func函数在A、B都有定义，但是func的参数没有D，只有D的父类C，那么需要按照this.show(super(O)) >>super.show(super(O))的顺序去选择函数。
