访问者模式(VisitorPattern)
属于对象行为型模式
的一种,表示一个作用于其对象结构中的各元素的操作,它使你可以在不改变各元素类的前提下定义作用于这些元素的新操作。
访问者模式: 预留通路,回调实现。它的实现主要就是通过预先定义好调用的通路,在被访问的对象上定义 accept方法
,在访问者的对象上定义 visit方法
;然后在调用真正发生的时候,通过两次分发的技术,利用预先定义好的通路,回调到访问者具体的实现上。
主要解决
现已稳定的数据结构和易变的操作耦合问题,把数据结构和作用于结构上的操作解耦合,使得操作集合可相对自由地演化。
UML结构图
模式结构
(Element)
访问的行为,它的参数就是可以访问的元素,它的方法个数理论上来讲与元素个数(Element的实现类个数)是一样的,从这点不难看出,访问者模式要求元素类的个数不能改变(不能改变的意思是说,如果元素类的个数经常改变,则说明不适合使用访问者模式)。accept
)的方法,其意义是指,每一个元素都要可以被访问者访问。Element
),并且可以迭代这些元素,供访问者访问。场景:很多人都有养宠物的习惯,这里就以此为例
结构图如下:
1.创建抽象访问者接口
interface Person {
void feed(Cat cat);
void feed(Dog dog);
}
2.创建不同的具体访问者角色 -- 主人/其他人,同时实现 Person
接口
class Owner implements Person {
@Override
public void feed(Cat cat) {
System.out.println("主人喂食猫");
}
@Override
public void feed(Dog dog) {
System.out.println("主人喂食狗");
}
}
class Someone implements Person {
@Override
public void feed(Cat cat) {
System.out.println("其他人喂食猫");
}
@Override
public void feed(Dog dog) {
System.out.println("其他人喂食狗");
}
}
3.创建 抽象节点 -- 宠物
interface Animal {
void accept(Person person);
}
4.创建实现 Animal
接口的 具体节点(元素)
class Dog implements Animal {
@Override
public void accept(Person person) {
person.feed(this);
System.out.println("好好吃,汪汪汪!!!");
}
}
/**
* 具体节点(元素)角色 -- 宠物猫
*/
class Cat implements Animal {
@Override
public void accept(Person person) {
person.feed(this);
System.out.println("好好吃,喵喵喵!!!");
}
}
5.创建实现 Animal
接口的 具体节点(元素)
class Home {
private List<Animal> nodeList = new ArrayList<>();
void action(Person person) {
for (Animal node : nodeList) {
node.accept(person);
}
}
/**
* 添加操作
*
* @param animal 动物
*/
void add(Animal animal) {
nodeList.add(animal);
}
}
6.创建客户端,用于测试
public class Client {
public static void main(String[] args) {
Home home = new Home();
home.add(new Dog());
home.add(new Cat());
Owner owner = new Owner();
home.action(owner);
Someone someone = new Someone();
home.action(someone);
}
}
7.运行结果
主人喂食狗
好好吃,汪汪汪!!!
主人喂食猫
好好吃,喵喵喵!!!
其他人喂食狗
好好吃,汪汪汪!!!
其他人喂食猫
好好吃,喵喵喵!!!
变量被声明时的类型叫做变量的静态类型(Static Type),有些人又把静态类型叫做明显类型(Apparent Type);而变量所引用的对象的真实类型又叫做变量的实际类型(Actual Type)。
比如:
Map map = null;
map = new HashMap();
声明了一个变量map,它的静态类型(也叫明显类型)是Map,而它的实际类型是HashMap。
根据对象的类型而对方法进行的选择,就是分派(Dispatch),分派(Dispatch)又分为两种,即静态分派和动态分派。
静态分派(Static Dispatch) 发生在编译时期,分派根据静态类型信息发生。静态分派对于我们来说并不陌生,方法重载就是静态分派。
动态分派(Dynamic Dispatch) 发生在运行时期,动态分派动态地置换掉某个方法。
静态分派:Java通过方法重载支持静态分派。
动态分派:Java通过方法的重写支持动态分派。
通过方法的重写支持动态分派。
class Dog {
public void execute() {
System.out.println("上古 Dog");
}
}
class DogBaby1 extends Dog {
@Override
public void execute() {
System.out.println("上古 Dog 第一代子孙");
}
}
class DogBaby2 extends Dog {
@Override
public void execute() {
System.out.println("上古 Dog 第二代子孙");
}
}
/**
* @author Levin
*/
public class Client {
public static void main(String[] args) {
Dog baby1 = new DogBaby1();
baby1.execute();
Dog baby2 = new DogBaby2();
baby2.execute();
}
}
变量baby1的静态类型是Dog,而真实类型是DogBaby1。
execute()方法调用的是DogBaby1类的execute()方法,那么上面打印的就是 上古Dog第一代子孙
;
变量baby2的静态类型是Dog,而真实类型是DogBaby2。
execute()方法调用的是DogBaby2类的execute()方法,那么上面打印的就是 上古Dog第二代子孙
;
所以,问题的核心就是Java编译器在编译时期并不总是知道哪些代码会被执行,因为编译器仅仅知道对象的静态类型,而不知道对象的真实类型;而方法的调用则是根据对象的真实类型,而不是静态类型。
通过方法重载支持静态分派。
class Dog {
}
class DogBaby1 extends Dog {
}
class DogBaby2 extends Dog {
}
class Execute {
public void execute(Dog dog) {
System.out.println("上古 Dog");
}
public void execute(DogBaby1 baby1) {
System.out.println("上古 Dog 第一代子孙");
}
public void execute(DogBaby2 baby2) {
System.out.println("上古 Dog 第二代子孙");
}
}
/**
* @author Levin
* @create 2017/12/19 0019
*/
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.execute(dog);
exe.execute(baby1);
exe.execute(baby2);
}
}
显然,Execute类的excute()方法是由三个方法重载而成的。这三个方法分别接受狗(Dog)、狗baby1(DogBaby1)、狗baby2(DogBaby2)等类型的参数。
运行结果
上古 Dog
上古 Dog
上古 Dog
为什么呢?三次对execute()方法的调用传入的是不同的参数,分别是dog、baby1、baby2。它们虽然具有不同的真实类型,但是它们的静态类型都是一样的,均是Dog类型。
重载方法的分派是根据静态类型进行的,这个分派过程在编译时期就完成了。
Java是静态多分派、动态单分派的语言。
Java不支持动态的双分派。但是通过使用设计模式,也可以在Java语言里实现动态的双重分派。
首先,什么是双分派?还记得 设计模式解密(22)- 访问者模式 中举的例子吗?
访问者模式用到了一种双分派的技术,所谓双分派技术就是在选择一个方法的时候,不仅仅要根据消息接收者(receiver)的运行时区别(Run time type),还要根据参数的运行时区别。
在访问者模式中,客户端将具体状态当做参数传递给具体访问者,这里完成第一次分派,然后具体访问者作为参数的具体状态中的方法,同时也 将自己this作为参数传递进去,这里就完成了第二次分派
。双分派意味着得到的执行操作决定于请求的种类和接受者的类型。
双分派的核心就是这个 this
对象。
说到这里,我们已经明白双分派是怎么回事了,但是它有什么效果呢?就是可以实现方法的动态绑定,我们可以对上面的程序进行修改。
class Dog {
public void accept(Execute exe) {
exe.execute(this);
}
}
class DogBaby1 extends Dog {
@Override
public void accept(Execute exe) {
exe.execute(this);
}
}
class DogBaby2 extends Dog {
@Override
public void accept(Execute exe) {
exe.execute(this);
}
}
class Execute {
public void execute(Dog dog) {
System.out.println("上古 Dog");
}
public void execute(DogBaby1 baby1) {
System.out.println("上古 Dog 第一代子孙");
}
public void execute(DogBaby2 baby2) {
System.out.println("上古 Dog 第二代子孙");
}
}
/**
* 双重分派
*
* @author Levin
* @create 2017/12/19 0019
*/
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
上古 Dog 第一代子孙
上古 Dog 第二代子孙
从结果可以看出:双分派实现动态绑定的本质,就是在重载方法委派的前面加上了继承体系中覆盖的环节,由于覆盖是动态的,所以重载就是动态的了!!!
访问者模式把数据结构和作用于结构上的操作解耦合,使得操作集合可相对自由地演化。访问者模式适用于数据结构相对稳定算法又易变化的系统。因为访问者模式使得算法操作增加变得容易。若系统数据结构对象易于变化,经常有新的数据对象增加进来,则不适合使用访问者模式。
优点
缺点
访问者
和 ObjectStructrue
,这破坏了对象的封装性。使用场景
参考文献:http://www.cnblogs.com/JsonShare/p/7380772.html
全文代码:https://gitee.com/battcn/design-pattern/tree/master/Chapter19/battcn-visitor