访问者模式讨论篇：java的动态绑定与双分派

java的动态绑定

所谓的动态绑定就是指程执行期间（而不是在编译期间） 判断所引用对象的实际类型，根据其实际的类型调用其相应的方法。 java继承体系中的覆盖就是动态绑定的，看一下如下的代码：

    class Father {
        public void method(){
            System.out.println("This is Father's method");
        }
    }

    class Son1 extends Father{
        public void method(){
            System.out.println("This is Son1's method");
        }
    }

    class Son2 extends Father{
        public void method(){
            System.out.println("This is Son2's method");
        }
    }

    public class Test {
        public static void main(String[] args){
            Father s1 = new Son1();
            s1.method();

            Father s2 = new Son2();
            s2.method();
        }
    }

运行结果如下：

This is Son1's method This is Son2's method

通过运行结果可以看到，尽管我们引用的类型是Father类型的， 但是运行时却是调用的它实际类型（也就是Son1和Son2）的方法， 这就是动态绑定。在java语言中，继承中的覆盖就是是动态绑定的， 当我们用父类引用实例化子类时，会根据引用的实际类型调用相应的方法。

java的静态绑定

相对于动态绑定，静态绑定就是指在编译期就已经确定执行哪一个方法。 在java中，方法的重载（方法名相同而参数不同）就是静态绑定的， 重载时，执行哪一个方法在编译期就已经确定下来了。看一下代码：

    class Father {}
    class Son1 extends Father{}
    class Son2 extends Father{}

    class Execute {
        public void method(Father father){
            System.out.println("This is Father's method");
        }

        public void method(Son1 son){
            System.out.println("This is Son1's method");
        }

        public void method(Son2 son){
            System.out.println("This is Son2's method");
        }
    }

    public class Test {
        public static void main(String[] args){
            Father father = new Father();
            Father s1 = new Son1();
            Father s2 = new Son2();

            Execute exe = new Execute();
            exe.method(father);
            exe.method(s1);
            exe.method(s2);
        }
    }

运行结果如下：

This is Father's method This is Father's method This is Father's method

在这里，程序在编译的时候就已经确定使用method(Father father)方法了， 不管我们在运行的时候传入的实际类型是什么， 它永远都只会执行method(Father father)这个方法。 也就是说，java的重载是静态绑定的。

instanceof操作符与转型

有时候，我们希望在使用重载的时候， 程序能够根据传入参数的实际类型动态地调用相应的方法， 也就是说，我们希望java的重载是动态的，而不是静态的。 但是由于java的重载不是动态绑定，我们只能通过程序来人为的判断， 我们一般会使用instanceof操作符来进行类型的判断。 我们要对method(Father father)进行修改 ，在方法体中判断运行期间的实际类型， 修改后的method(Father father)方法如下：

    public void method(Father father){
        if(father instanceof Son1){
            method((Son1)father);
        }else if(father instanceof Son2){
            method((Son2)father);
        }else if(father instanceof Father){
            System.out.println("This is Father's method");
        }
    }

请注意，我们必须把判断是否是父类的条件 （也就是判断是否为Father类的条件）放到最后， 否则将一律会被判断为Father类，达不到我们动态判断的目的。 修改代码后，程序就可以动态地根据参数的实际类型来调用相应的方法了。 运行结果如下：

This is Father's method This is Son1's method This is Son2's method

但是这种实现方式有一个明显的缺点，它是伪动态的， 仍然需要我们来通过程序来判断类型。 假如Father有100个子类的话，还是这样来实现显然是不合适的。 必须通过其他更好的方式实现才行，我们可以使用双分派方式来实现动态绑定。

用双分派实现动态绑定

首先，什么是双分派？ 还记得23种设计模式（9）： 访问者模式中一开始举的例子吗？

类A中的方法method1和method2的区别就是， method2是双分派。我们可以看一下java双分派的特点： 首先要有一个访问类B，类B提供一个showA(A a) 方法， 在方法中，调用类A的method1方法， 然后类A的method2方法中调用类B的showA方法并将自己作为参数传给showA。 双分派的核心就是这个this对象。说到这里，我们已经明白双分派是怎么回事了，但是它有什么效果呢？就是可以实现方法的动态绑定，我们可以对上面的程序进行修改，代码如下：

    class Father {
        public void accept(Execute exe){
            exe.method(this);
        }
    }
    class Son1 extends Father{
        public void accept(Execute exe){
            exe.method(this);
        }
    }
    class Son2 extends Father{
        public void accept(Execute exe){
            exe.method(this);
        }
    }

    class Execute {
        public void method(Father father){
            System.out.println("This is Father's method");
        }

        public void method(Son1 son){
            System.out.println("This is Son1's method");
        }

        public void method(Son2 son){
            System.out.println("This is Son2's method");
        }
    }

    public class Test {
        public static void main(String[] args){
            Father father = new Father();
            Father s1 = new Son1();
            Father s2 = new Son2();

            Execute exe = new Execute();
            father.accept(exe);
            s1.accept(exe);
            s2.accept(exe);
        }
    }

可以看到我们修改的地方， 在Father，Son1，Son2中分别加入一个双分派的方法。 调用的时候，原本是调用Execute的method方法 ，现在改为调用Father的accept方法。运行结果如下：

This is Father's method This is Son1's method This is Son2's method

运行结果符合我们的预期，实现了动态绑定。 双分派实现动态绑定的本质， 就是在重载方法委派的前面加上了继承体系中覆盖的环节， 由于覆盖是动态的，所以重载就是动态的了， 与使用instanceof操作符的效果是一样的 （用instanceof操作符可以实现重载方法动态绑定的原因也是因为instanceof操作符是动态的）。 但是与使用instanceof操作符实现动态绑定相比， 双分派方式的可扩展性要好的多。