访问者模式基础篇 :http://www.cnblogs.com/JsonShare/p/7380772.html
访问者模式扩展篇 - 分派的概念: http://www.cnblogs.com/JsonShare/p/7381705.html
变量被声明时的类型叫做变量的静态类型 (Static Type),有些人又把静态类型叫做明显类型 (Apparent Type);而变量所引用的对象的真实类型又叫做变量的实际类型 (Actual Type)。比如:
- Map map = null;
- map = new HashMap();
声明了一个变量 map,它的静态类型(也叫明显类型)是 Map,而它的实际类型是 HashMap。
根据对象的类型而对方法进行的选择,就是分派 (Dispatch),分派(Dispatch) 又分为两种,即静态分派和动态分派。
静态分派 (Static Dispatch) 发生在编译时期,分派根据静态类型信息发生。静态分派对于我们来说并不陌生,方法重载就是静态分派。
动态分派 (Dynamic Dispatch) 发生在运行时期,动态分派动态地置换掉某个方法。
静态分派:Java 通过方法重载支持静态分派。
动态分派:Java 通过方法的重写支持动态分派。
Java 通过方法的重写支持动态分派。
实例:
- package com.designpattern.Visitor.expand.Dynamic;
- /**
- * 动态分派
- * @author Json<<json1990@foxmail.com>>
- */
- class Dog {
- public void excute() {
- System.out.println("我是dog妈妈");
- }
- }
- class DogBaby1 extends Dog {
- public void excute() {
- System.out.println("我是dogbaby1");
- }
- }
- class DogBaby2 extends Dog {
- public void excute() {
- System.out.println("我是dogbaby2");
- }
- }
- public class Client {
- public static void main(String[] args) {
- Dog baby1 = new DogBaby1();
- baby1.excute();
- Dog baby2 = new DogBaby2();
- baby2.excute();
- }
- }
变量 baby1 的静态类型是 Dog,而真实类型是 DogBaby1。
excute() 方法调用的是 DogBaby1 类的 excute() 方法,那么上面打印的就是 "我是 dogbaby1";
变量 baby2 的静态类型是 Dog,而真实类型是 DogBaby2。
excute() 方法调用的是 DogBaby2 类的 excute() 方法,那么上面打印的就是 "我是 dogbaby2";
所以,问题的核心就是 Java 编译器在编译时期并不总是知道哪些代码会被执行,因为编译器仅仅知道对象的静态类型,而不知道对象的真实类型;而方法的调用则是根据对象的真实类型,而不是静态类型。
Java 通过方法重载支持静态分派。
实例:
- package com.designpattern.Visitor.expand.Static;
- /**
- * 静态分派
- * @author Json<<json1990@foxmail.com>>
- */
- class Dog {
- }
- class DogBaby1 extends Dog {
- }
- class DogBaby2 extends Dog {
- }
- class Execute {
- public void excute(Dog dog) {
- System.out.println("我是dog妈妈");
- }
- public void excute(DogBaby1 baby1) {
- System.out.println("我是dogbaby1");
- }
- public void excute(DogBaby2 baby2) {
- System.out.println("我是dogbaby2");
- }
- }
- public class Client {
- public static void main(String[] args) {
- Dog dog = new Dog();
- Dog baby1 = new DogBaby1();
- Dog baby2 = new DogBaby2();
- Execute exe = new Execute();
- exe.excute(dog);
- exe.excute(baby1);
- exe.excute(baby2);
- }
- }
显然,Execute 类的 excute()方法是由三个方法重载而成的。这三个方法分别接受狗 (Dog)、狗 baby1(DogBaby1)、狗 baby2(DogBaby2) 等类型的参数。
那么在运行时,程序会打印出什么结果呢?
- 我是dog妈妈
- 我是dog妈妈
- 我是dog妈妈
为什么呢?三次对 excute() 方法的调用传入的是不同的参数,分别是 dog、baby1、baby2。它们虽然具有不同的真实类型,但是它们的静态类型都是一样的,均是 Dog 类型。
重载方法的分派是根据静态类型进行的,这个分派过程在编译时期就完成了。
Java 是静态多分派、动态单分派的语言。
Java 不支持动态的双分派。但是通过使用设计模式,也可以在 Java 语言里实现动态的双重分派。
首先,什么是双分派?还记得 设计模式解密(22)- 访问者模式 中举的例子吗?
访问者模式用到了一种双分派的技术,所谓双分派技术就是在选择一个方法的时候,不仅仅要根据消息接收者(receiver)的运行时区别(Run time type),还要根据参数的运行时区别。在访问者模式中,客户端将具体状态当做参数传递给具体访问者,这里完成第一次分派,然后具体访问者作为参数的 "具体状态" 中的方法,同时也将自己 this 作为参数传递进去,这里就完成了第二次分派。双分派意味着得到的执行操作决定于请求的种类和接受者的类型。
双分派的核心就是这个 this 对象。
说到这里,我们已经明白双分派是怎么回事了,但是它有什么效果呢?就是可以实现方法的动态绑定,我们可以对上面的程序进行修改。
代码:
- package com.designpattern.Visitor.expand.doubleDispatch;
- /**
- * 双重分派
- * @author Json<<json1990@foxmail.com>>
- */
- class Dog {
- public void accept(Execute exe) {
- exe.excute(this);
- }
- }
- class DogBaby1 extends Dog {
- public void accept(Execute exe) {
- exe.excute(this);
- }
- }
- class DogBaby2 extends Dog {
- public void accept(Execute exe) {
- exe.excute(this);
- }
- }
- class Execute {
- public void excute(Dog dog) {
- System.out.println("我是dog妈妈");
- }
- public void excute(DogBaby1 baby1) {
- System.out.println("我是dogbaby1");
- }
- public void excute(DogBaby2 baby2) {
- System.out.println("我是dogbaby2");
- }
- }
- public class Client {
- public static void main(String[] args) {
- Dog dog = new Dog();
- Dog baby1 = new DogBaby1();
- Dog baby2 = new DogBaby2();
- Execute exe = new Execute();
- dog.accept(exe);
- baby1.accept(exe);
- baby2.accept(exe);
- }
- }
结果:
- 我是dog妈妈
- 我是dogbaby1
- 我是dogbaby2
从结果可以看出:双分派实现动态绑定的本质,就是在重载方法委派的前面加上了继承体系中覆盖的环节,由于覆盖是动态的,所以重载就是动态的了!!!
PS:源码地址 https://github.com/JsonShare/DesignPattern/tree/master
来源: http://www.cnblogs.com/JsonShare/p/7381705.html