java夯实基础之多态性

一、多态定义

    行为上：允许不同的类的对象对于同一消息作出反应。同一消息可根据发送对象的不同采用不同的行为方式。

    实现上：编译时类型（定义该变量时使用的类型）和使用编译时类型调用的方法在编程时并不确定而是在程序运行时才确定，实现不修改源码而让编译时变量绑定到不同的类的实现上，从而使得程序可以选择多个运行状态。

二、多态存在必要条件

    1.继承：存在继承关系的父类和子类

    2.重写：子类重写父类中的某些方法

    3.向上转型

三、多态中的方法执行

public class Father {
        public void fun1() {
            System.out.print("father  fun1");
            fun2();
        }

        public void fun2() {
            System.out.print("father  fun2");
        }
    }

    public class Son extends Father {
        public void fun1(String s) {
            System.out.print("son  fun1");
            fun2();
        }

        public void fun2() {
            System.out.print("son  fun2");
        }
    }


    public class Test {
        public void main(String[] args) {
            Father a = new Son();
            a.fun1();
        }
    }

    输出结果：

father fun1 son fun2

    结果分析：向上转型会导致一些方法的丢失，父类引用只能调用父类中定义的属性和方法，对于存在于子类中的其他方法无法获取。实例中子类重写类fun2方法，重载了fun1方法，重载后的fun1方法和父类中的fun1方法并不是同一个方法，向上转型时丢失。引用变量在编译阶段调用编译时类型具有的方法，但运行时执行运行时类型具有但方法系统总是试图访问引用变量定义的成员即父类变量的成员。
总结：执行方法时会首先从父类中查找到对应的方法，寻找不到则报异常，寻找到后若该方法在子类中重写了则执行子类中的该方法，若子类中未重写或者重载了该方法则执行父类方法。结合理解相当于执行了最底层的叶节点的方法。

    再结合例子进行实践，代码如下，参考：http://www.cnblogs.com/chenssy/p/3372798.html

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

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

}

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

public class C extends B{

}

public class D extends B{

}

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("1--" + a1.show(b));
        System.out.println("2--" + a1.show(c));
        System.out.println("3--" + a1.show(d));
        System.out.println("4--" + a2.show(b));
        System.out.println("5--" + a2.show(c));
        System.out.println("6--" + a2.show(d));
        System.out.println("7--" + b.show(b));
        System.out.println("8--" + b.show(c));
        System.out.println("9--" + b.show(d));      
    }
}

    执行结果如下：

1--A and A
2--A and A
3--A and D
4--B and A
5--B and A
6--A and D
7--B and B
8--B and B
9--A and D

    结合a2.show(b)给出分析过程，a2时A类型变量，首先到A类中去查找和show(b)对应的方法，查找到show(A obj)方法(B向上转型为A类型),此时查找B类中存在着show(A obj)的重写，则此时执行B类中的show(A obj)方法打印B and A。 

    而b.show(d)则是b类中不存在该方法，到父类中查找到了对应的方法则执行。

四、多态的实现

    1.基于继承实现的多态

    2.基于接口实现的多态，多个类引用同一接口并覆写接口中的方法。

五、多态的好处

    可替换性（对于已存在到代码具有可替换性）、可扩充性（新增加子类不影响已存在类的特性）、接口性（父类中定义方法提供给子类覆写）、灵活性、简化性（简化了编码过程，适用于大量对象运算操作）

    特记下，以备后日回顾。