理解面向对象中的多态、静态绑定、动态绑定

什么是多态

多态性是指允许不同类的对象对同一消息作出响应，多态性包括参数化多态性和包含多态性，多态性语言具有灵活、抽象、行为共享、代码共享的优势，很好的解决了应用程序函数同名问题。

静态多态（参数多态）

静态多态在编译时就能确定要调用具体那个方法，例如Java中的方法重载（Overload）:

实验一：静态多态测试

下方代码中，一共有9重载方法，方法名称都为test，参数类型为7个基本类型和Serializable类型和Object类型。

class Foo {

    public void test(byte arg){
        System.out.println("call byte.");
    }

    public void test(short arg){
        System.out.println("call short.");
    }

    public void test(int arg){
        System.out.println("call int.");
    }

    public void test(long arg){
        System.out.println("call long.");
    }

    public void test(float arg){
        System.out.println("call float.");
    }

    public void test(double arg){
        System.out.println("call double.");
    }

    public void test(char arg){
        System.out.println("call char.");
    }

    public void test(Serializable arg){
        System.out.println("call Serializable [" + arg.getClass() + "].");
    }

    public void test(Object arg){
        System.out.println("call Object [" + arg.getClass() + "].");
    }


}

案例一： 用byte类型的参数，调用方法：

public class PolymorphismTest {

    public static void main(String[] args) {
        byte arg = 1;
        Foo foo = new Foo();
        foo.test(arg);
    }

}

输出结果：call byte.
通过IDE代码导航功能，按住Ctrl点击调用方法名，代码也可调到byte类型的方法上。
说明不需要运行就能确定，调用的是byte类型的方法。

案例二： 注释掉byte类型的方法，再次执行：
输出结果：call short.
说明没有byte类型的方法时，会调用short类型的方法。

案例三： 重复上述实验，哪个方法被执行了，就注释掉哪个，直到最后一个方法：
依次输出结果（不是一次的输出结果，每一行代表按顺序注释掉上次运行调用的方法后的执行结果）：

call byte.
call short.
call int.
call long.
call float.
call double.
call char.
call Serializable [class java.lang.Byte].
call Object [class java.lang.Byte].

得到调用重载方法的优先匹配顺序：
参数类型为byte时：byte short int long float double Serializable Object
参数类型为char时：char int long float double Serializable Object （自行尝试）
从byte到Object，从char到Object，左边的类型都可以安全转换到右边的类型，所以重载方法优先取最接近的类型，到Serializable 等类型时会自动进行装箱。

案例四： byte类型能不能直接转换到Short包装类型：

class Foo {

//    public void test(byte arg){
//        System.out.println("call byte.");
//    }

    public void test(Short arg){
        System.out.println("call short.");
    }

    public void test(int arg){
        System.out.println("call int.");
    }

输出结果：call int.
byte不能一次就转换成为Short，没有匹配上，直接匹配到int类型方法了。

案例五： 重载方法匹配用的是静态类型还是动态类型

什么是静态类型、动态类型？

静态类型： 编译时就能确认的类型
动态类型： 运行时的实际类型
如下方代码，可以变量serial2的一定是一个Object类型的对象（Object或者Object的子类），所以变量serial2的静态类型是Object，下方代码实际运行时，变量serial1由1进行自动装箱成Integer类型，所以此时变量serial2动态类型是Integer，是Object的一个具体子类，如果serial1是通过方法参数传递进来的，不同调用传进来的参数的具体类型不能一样，只有代码运行到时，才能确认参数的具体类型，这是动态类型。

    public static void main(String[] args) {
        Serializable serial1 = 1;
        Object serial2 = serial1;
        Foo foo = new Foo();
        foo.test(serial1);
        foo.test(serial2);
    }

运行结果：

call Serializable [class java.lang.Integer].
call Object [class java.lang.Integer].

说明调用重载方法时用静态类型确定要调用的方法，这次代码运行中变量serial1、serial2的动态类型都是Integer，变量serial1的静态类型是Serializable，变量serial2的静态类型是Object ，方法重载在编译时就能确定要调用哪个方法，这也成为方法的静态绑定，动态类型要在运行时才知道，从这个方面思考，重载方法的匹配用的也一定是静态类型。

动态多态（包含多态）

动态多态运行时才能确定要调用哪个方法，例如如Java的方法重写（Override）：

实验二：动态多态测试
Animal类及其两个子类Cat类和Dog类，三个类都实现了bark方法。

class Animal{
    void bark(){
        System.out.println("Animal bark.");
    }
}

class Cat extends Animal{

    @Override
    void bark() {
        System.out.println("Cat bark.");
    }
}

class Dog extends Animal{
    @Override
    void bark() {
        System.out.println("Dog bark.");
    }
}

public class PolymorphismTest {

    @Test
    public void test2(){
        bark(new Animal());
        bark(new Cat());
        bark(new Dog());
    }

    public void bark(Animal animal){
        animal.bark();
    }

}

运行结果：

Animal bark.
Cat bark.
Dog bark.

动态多态的体现在PolymorphismTest中animal.bark()这一行调用但看这个方法代码是无法确认具体调用是哪个类的bark方法，要根据方法参数animal的实际类型才能确定，也就是说要在运行时才能确定（区别于静态多态/方法重载的编译时就能确定），这种调用也称动态绑定。

方法的静态绑定和动态绑定

静态绑定： 编译时就能确定要调用哪个方法，如实验一中关于静态多态（方法重载）的测试，根据静态类型（编译类型）byte就能确定要执行哪个方法，优先匹配更接近的类型（安全类型转换链条上相近）。

动态绑定： 运行时根据对象实际类型确定要调用哪个方法，如实验二关于动态多态（方法重写）的测试，根据对象的实际类型，选择执行具体某个子类方法，要运行时才能知道对象的具体类型，根据对象类型选择执行不同的方法。

总结

多态性是指允许不同类的对象对同一消息作出响应，多态性包括参数化多态性和包含多态性，多态性语言具有灵活、抽象、行为共享、代码共享的优势，很好的解决了应用程序函数同名问题。

静态多态： 根据方法参数(消息是面向对象里面的概念)来确认要调用的方法，在编译时就能根据参数的静态类型确定要调用的方法。
静态绑定： 在编译时就能确认调用具体方法。
动态多态： 根据对象的实际类型(消息的接收者)来确认要调用的方法，只能在运行时根据对象的实际类型确定。
动态绑定： 在运行时，根据对象类型动态选择要执行的方法。