Java多态

多态概念

多态是指程序中定义的引用变量所指向的具体类型和通过该引用变量发出的方法调用在编程时并不确定，而是在程序运行期间才确定，即一个引用变量倒底会指向哪个类的实例对象，该引用变量发出的方法调用到底是哪个类中实现的方法，必须在由程序运行期间才能决定。因为在程序运行时才确定具体的类，即不修改程序代码就可以改变程序运行时所绑定的具体代码，让程序可以选择多个运行状态，这就是多态性。多态性增强了软件的灵活性和扩展性

实现多态的机制
靠的是父类或接口定义的引用变量可以指向子类或具体实现类的实例对象，而程序调用的方法在运行期才动态绑定，就是引用变量所指向的具体实例对象的方法，也就是内存里正在运行的那个对象的方法，而不是引用变量的类型中定义的方法

说到这里 面向对象特征 ：封装、继承 其实都是为了多态而准备的

一个多态的例子

package com.hfview.duotai;
/* 前3句都是调用a1的方法，a1申明和实例化的时候都是A类的对象，所以只看A类的方法 1. a1.show(b) b申明的类型是B，所以最恰当的是调用show(A obj) 打印 A and A 2. a1.show(c) c申明的类型是C，所以最恰当的是调用show(A obj) 打印A and A 3. a1.show(d) d申明的类型是D，所以最恰当的是调用show(D obj) 打印A and D 中间3句都是调用a2的方法，a2申明为A类，虽然实例化的时候是B类的对象，但是对于编译器来讲 只有A类有的方法才是可以调用的，所以在调用哪个方法时看A类，如果B类覆盖了A类的某个方法， 那么在具体调用的时候会调用B类的版本。所以：对a2对象来说，只有两个方法，分别是： public String show(D obj) { return ("A and D"); } public String show(A obj) { return ("B and A"); } 4. a2.show(b) b申明的类型是B，所以最恰当的是调用show(A obj) 打印 B and A 5. a2.show(c) c申明的类型是C，所以最恰当的是调用show(A obj) 打印 B and A 6. a2.show(d) d申明的类型是D，所以最恰当的是调用show(D obj) 打印 A and D 最后3句都是调用b的方法，b申明和实例化的时候都是B类的对象，所以只看B类的方法（包括从A类继承的方法） 7. b.show(b) b申明的类型是B，所以最恰当的是调用show(B obj) 打印 B and B 8. b.show(c) c申明的类型是C，C直接继承B，所以最恰当的是调用show(B obj) 打印 B and B 9. b.show(d) d申明的类型是D，所以最恰当的是调用show(D obj) 打印 A and D */
class B extends A{  
    public String show(B obj){  
           return ("B and B");  
    }  
    public String show(A obj){  
           return ("B and A");  
    }   
} 

public class A {

    public String show(D obj) {
        return ("A and D");
    }

    public String show(A obj) {
        return ("A and A");
    }


    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(); 
        /* *分析 D obj = new B(); 这种不可取 * A obj = new B() * 打印的是 "A and A" */
        System.out.println(a1.show(b));

        /* * D obj = new C(); 这种不可取 * A obj = new C() * "A and A" */
        System.out.println(a1.show(c)); 

        /* * D obj = new D(); 比较应该取 这个 * A obj = new D(); * 这个应该是 "A and D" */
        System.out.println(a1.show(d));

        /* * 分析:这里A父亲指向了子类B的初始化对象，然后运行的时候应该运行B的实现 * 首先在a2引用的是A类,运行的时候去寻找是否有这个方法,正好匹配到show(A obj)这个方法 * 然而这个方法有重写 也就是B类中的 show(A obj);(如果是成员变量就会调用A的，因为成员变量不能重写) * 所以就会调用B类中的show(A obj) 输出 "B and A"　 */
        System.out.println(a2.show(b));    

        /* * 这个和上个类似 输出"B and A" */
        System.out.println(a2.show(c));  

        /* * 首先在a2引用的是A类,运行的时候去寻找是否有这个方法,正好匹配到show(D obj)这个方法 * 这个方法在子类中没有重写 所以调用A中的show(D obj) 输出"A and D" */
        System.out.println(a2.show(d));    

        /* * b 申明的是B 引用的实例对象也是B 当调用的时候 b.show(b) 正好匹配 B类中的show(b) * "B and B" */
        System.out.println(b.show(b)); 

        /* * b 申明的是B 引用的实例对象也是B 当调用的时候 b.show(c) B类中没有最合适的，只有 * show(b)能适配,然后在父类中也是没有最合适的皮匹配所以直接调用了B的show(b) * "B and B" */
        System.out.println(b.show(c));  
        /* * b 申明的是B 引用的实例对象也是B 当调用的时候 b.show(c) B类中没有最合适的，只有 * show(b)能适配,然后在父类A中找到了最合适的匹配 所以直接调用了A的show(D obj) * 输出 “A and D” */
        System.out.println(b.show(d));
    }
}

class C extends B{}   
class D extends B{}