前言

我们知道，面向对象三大特性里，封装、继承和多态里，多态是最复杂的。
多态的实现方式分为接口、重写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))的顺序去选择函数。

附录；

主要针对做Android开发1到5年，需要系统深入的提升完善自己的技术体系的开发者朋友。大佬们就不用看了哈哈

附录一；Android高级技术大纲

附录二；Android进阶实战技术视频

 

获取方式；

加Android进阶群；701740775。即可前往免费领取。麻烦备注一下csdn领取资料