首页 > 代码库 > java的动态绑定与双分派(规避instanceof)

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

2024-07-09 05:42:10   219人阅读

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");    }}

 

执行的结果： 

personpersonperson

不管在运行的时候传入的实际类型是什么，它永远都只会执行 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");    }}

 

结果： 

personmanwoman

 

 

      这种实现方式有一个明显的缺点，它是伪动态的，仍然需要我们来通过程序来判断类型。假如有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");    }}

 

 

 

 

 

 

 

 

 

 

 

 


联系
我们