java的动态绑定与双分派(规避instanceof)

1. 动态绑定的概念

指程执行期间（而不是在编译期间）判断所引用对象的实际类型，根据其实际的类型调用其相应的方法 .

例如：

package org.demo.clone.demo;

public class DynamicBound {
    public static void main(String[] args) {
          Person person = new Man() ;
          person.say() ;
    }
}

class Person{
    public void say(){} ;
}

class Man extends Person{
    public void say(){
        System.out.println("Hey Man");
    }
}

结果：

Hey Man

调用的是Person对象中的say方法 但是实际执行的是Man中的方法，这就是动态绑定。 在java语言中，继承中的覆盖就是是动态绑定的，当我们用父类引用实例化子类时，会根据引用的实际类型调用相应的方法

2. 静态绑定

静态绑定就是指在编译期就已经确定执行哪一个方法。方法的重载（方法名相同而参数不同）就是静态绑定的，重载时，执行哪一个方法在编译期就已经确定下来

package org.demo.demo;

public class StaticBound {
    public static void main(String[] args) {
        OutputName out = new OutputName() ;
        Person p = new Person() ;
        Person man = new Man() ;
        Person woman = new Woman() ;
        out.print(p) ;
        out.print(man) ;
        out.print(woman) ;
    }
}

class Person{
}

class Man extends Person{

}
class Woman extends Person{

}

class OutputName{
    void print(Person p){
        System.out.println("person");
    }
    void print(Man m){
        System.out.println("man");
    }
    void print(Woman w){
        System.out.println("woman");
    }
}

执行的结果：

person
person
person

不管在运行的时候传入的实际类型是什么，它永远都只会执行 void print(Person p)这个方法，即 : 重载是静态绑定的

　　如果希望使用重载的时候，程序能够根据传入参数的实际类型动态地调用相应的方法，也就是说，我们希望java的重载是动态的，而不是静态的。

但是由于java的重载不是动态绑定，只能通过程序来人为判断，我们一般会使用instanceof操作符来进行类型的判断  代码如下：

package org.demo.demo;

public class StaticBound {
    public static void main(String[] args) {
        OutputName out = new OutputName() ;
        Person p = new Person() ;
        Person man = new Man() ;
        Person woman = new Woman() ;
        out.print(p) ;
        out.print(man) ;
        out.print(woman) ;
    }
}

class Person{
}

class Man extends Person{

}
class Woman extends Person{

}

class OutputName{
    void print(Person p){
        if(p instanceof Man) print((Man)p);
        else if (p instanceof Woman) print((Woman)p);
        else  System.out.println("person");
    }
    void print(Man m){
        System.out.println("man");
    }
    void print(Woman w){
        System.out.println("woman");
    }
}

结果：

person
man
woman

这种实现方式有一个明显的缺点，它是伪动态的，仍然需要我们来通过程序来判断类型。假如有100个子类的话，还是这样来实现显然是不合适的

必须通过其他更好的方式实现才行，我们可以使用双分派方式来实现动态绑定

3. 使用双分派实现动态绑定

什么是双分派：

package org.demo.demo;
/**
 * 双分派
 */
public class DoubleAssign {
    public static void main(String[] args) {
        A a = new A() ;
        a.method02(new B()) ;
    }

}

class A {
    public void method01(){
        System.out.println("\t method01");
    }
    public void method02(B  b ){
        b.classMethod01(this) ;
    }
}

class B{
    public void classMethod01(A a ){
        System.out.println("------classMethod01 start----- ");
        a.method01();
        System.out.println("------classMethod01 end----- ");
    }
}

通过双分派实现动态绑定

package org.demo.demo.foo;
/**
 * 通过双分派实现动态绑定
 */
public class DoubleAssignForDynamicBound {
    public static void main(String[] args) {
        OutputName out = new OutputName() ;
        Person p = new Person() ;
        Person man = new Man() ;
        Person woman = new Woman() ;
        p.accept(out) ;
        man.accept(out) ;
        woman.accept(out) ;
    }
}

class Person{
    public void accept(OutputName out) {
        out.print(this) ;
    }
}

class Man extends Person{
    public void accept(OutputName out) {
        out.print(this) ;
    }
}
class Woman extends Person{
    public void accept(OutputName out) {
        out.print(this) ;
    }
}

class OutputName{
    void print(Person p){
        System.out.println("person");
    }
    void print(Man m){
        System.out.println("man");
    }
    void print(Woman w){
        System.out.println("woman");
    }
}