多 态

    package com.maozj.javatnk.duotai; 
     
    import java.util.ArrayList; 
    import java.util.Map; 
     
    public class ParentObj { 
        public void doWork(ArrayList list) { 
            System.out.println("ParentObj doWork..."); 
        } 
     
        public void doSport(Map map) { 
            System.out.println("ParentObj doSport..."); 
        } 
    } 


package com.maozj.javatnk.duotai; 
 
import java.util.HashMap; 
import java.util.List; 
 
public class ChildObj extends ParentObj { 
 
    public void doWork(List list) { 
        System.out.println("ChildObj doWork..."); 
    } 
 
    public void doSport(HashMap map) { 
        System.out.println("ChildObj doSport..."); 
    } 
 
}

    package com.maozj.javatnk.duotai; 
     
    import java.util.ArrayList; 
    import java.util.HashMap; 
     
    public class Client { 
     
        /**
         * @param args
         */ 
        public static void main(String[] args) { 
            test1(); 
            System.out.println("=================================="); 
            test2(); 
        } 
         
        public static void test1(){ 
            ParentObj po = new ParentObj(); 
            ArrayList list = new ArrayList(); 
            po.doWork(list); 
             
            po = new ChildObj(); 
            po.doWork(list); 
             
            ChildObj co = new ChildObj(); 
            co.doWork(list); 
             
        } 
         
        public static void test2(){ 
            ParentObj po = new ParentObj(); 
            HashMap map  = new HashMap(); 
            po.doSport(map); 
             
            po = new ChildObj(); 
            po.doSport(map); 
             
            ChildObj co = new ChildObj(); 
            co.doSport(map); 
        }    
    } 




首先，要明确，Child对Parent发生了方法的Overload而不是override，原因是参数类型不同。

接下来，再观察执行时的参数类型，分别是ArrayList和HashMap.

最后，再看调用对象的声明类型和实例类型，由于是Overload，所以Child的实例类型中实际上有4个方法，而不是2个，这个时候掉哪个完全看参数的匹配情况。




1.关于java的多态，它讲java的多态分成静态的多态，和动态的多态，而所谓静态的多态就是只函数的重载，动态的多态就是方法的覆写。

2.静态的多态性。系统会在你编译的时候根据你调用的方法的参数列表来动态的决定调用那一个函数。

3.还有一种多态性：动态多态性。Java实现运行时多态性的基础是动态方法调度，它是一种在运行时而不是在编译期调用重载方法的机制。动态性多态的例子，比如说"一个接口，多个方法"。

1. Java的多态性总结：

(1) 首先, 要明确Child对Parent发生了方法的overload还是overwrite，根据参数类型及个数。

(2) 如果是overload，则Child继承了Parent的方法，相当于Child多加了父类的方法。

(3) 如果是overwrite， 则Child类不会有父类的该方法，而是把该方法重写了，所以该方法存在于父类中，子类只是重写了。要想调用父类的该方法，只能通过super关键字调用。
    java 的这种机制遵循一个原则：当超类对象引用变量引用子类对象时，被引用对象的类型而不是引用变量的类型决定了调用谁的成员方法，但是这个被调用的方法必须是在超类中定义过的，也就是说被子类覆盖的方法。
(4) 接下来，观察方法执行时的参数类型；

(5) 然后看调用对象的声明类型和实例类型；

(6) 方法的调度采用最精确参数匹配。


2. 多态分两种：
(1) 编译时多态：编译时动态重载；
(2) 运行时多态：指一个对象可以具有多个类型，方法的覆盖
    这样对于对象而言分为：
    理解运行时多态：
    Car c = new Bus();
    Car编译时类型 编译时检查变量类型是否存在，是否有调用的方法。
    Bus运行时类型  实际运行是访问heap中的对象，调用实际的方法。
    运行时多态是由运行时类型决定的
    编译时多态是由编译时类型决定的