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 并不知道！
     */