JAVA多態的理解

面向對象的三大特性：封裝、繼承、多態，其中最難理解的就是多態

如下是網上某大神給的一個例子：

    1.繼承關係

class A {
         public String show(D obj){
                return ("A and D");
         }   
         public String show(A obj){
                return ("A and A");
         }
}
class B extends A {
         public String show(B obj){
                return ("B and B");
         }
         public String show(A obj){
                return ("B and A");
         }
}  
class C extends B {}   
class D extends B {}

    2. 測試

public class Test {
    public static void main(String[] args) {
        A a1 = new A();
        A a2 = new B();
        B b = new B();
        C c = new C();
        D d = new D();
        System.out.println(a1.show(b));    //1
        System.out.println(a1.show(c));    //2
        System.out.println(a1.show(d));    //3
        System.out.println(a2.show(b));    //4
        System.out.println(a2.show(c));    //5
        System.out.println(a2.show(d));    //6
        System.out.println(b.show(b));    //7
        System.out.println(b.show(c));    //8
        System.out.println(b.show(d));    //9
    }
}

    3. 輸出結果

A and A    //1
A and A    //2
A and D    //3
B and A    //4，這是要理解的重點
B and A    //5，這是要理解的重點
A and D    //6
B and B    //7
B and B    //8
A and D    //9

    4. 理解

    class A{}
    class B extends A{}
    A a = new B();
    /*
     * 1. 上面的結果是產生了一個 A 類對象，雖然實際上傳遞過來的是 B 類對象（向上轉型）
     * 2. 此時 a 只能調用 A 類中的方法，而看不到B類中的【特有】方法
     * 3. 若是 B 中複寫了 A 類中的某些方法，那麼此時 a 能調用到的都是被複寫的方法
     *
     * 形象一點就是 B 偷偷換了 A 中的一些方法，此時的 a 並不知道！
     */