模式说明

以不同地方的厨师对相同食材的处理为例描述访问者模式。例如对于鸡，广东厨师会按粤菜做法做成白斩鸡，而四川厨师会做成川菜辣子鸡。对于鱼也类似，广东厨师将其做成清蒸鱼而四川厨师会处理成水煮鱼。可以把厨师描述为访问者，食材是被访问对象，不同的访问者访问相同的对象有不同的结果。具有这种特征的行为模式就是访问者模式。

本示例中，厨师为抽象访问者，广东厨师和四川厨师为具体访问者。被访问事物是鸡和鱼，它们都继承一个抽象访问对象类。广东厨师处理(访问)鸡和鱼会做出白斩鸡和清蒸鱼，而四川厨师处理鸡和鱼会做出辣子鸡和水煮鱼。设置一个访问对象结构类，其内持有所有的访问对象，有管理访问对象的方法add(增加访问对象)和remove(移除访问对象)。在客户端声明一个访问对象结构，然后add具体的访问对象。接着声明具体访问者，调用访问对象结构的访问方法accpet(传入具体访问者)。最终得到该访问者访问所有访问对象的结果。

结构

抽象访问者类
定义对所有访问对象的抽象访问方法。
具体访问者类
继承抽象访问者类，实现抽象访问方法。
抽象访问对象类
定义抽象访问方法accept，用于接受一个具体的访问者类的访问。
具体访问对象类
继承抽象访问对象类，实现抽象方法accept。
访问对象结构类
持有访问对象的集合List<Material>，有若干管理访问对象的方法，有一个传入访问者的访问方法，方法内遍历其持有的访问对象并执行访问动作。

代码演示

  1. package com.yukiyama.pattern.behavior;
  3. import java.util.ArrayList;
  4. import java.util.List;
  6. /**
  7.  * 访问者模式
  8.  */
  9. public class VisitorDemo {
  11.     public static void main(String[] args) {
  12.         // 声明一个访问对象结构实例
  13.         ObjectStructure obj = new ObjectStructure();
  14.         // 增加访问对象至结构中
  15.         obj.add(new ChickenMaterial());
  16.         obj.add(new FishMaterial());
  17.         // 声明访问者
  18.         Cook gdCook = new GuangdongCook();
  19.         Cook scCook = new SichuanCook();
  20.         // 访问对象结构执行其accept方法，接收具体访问者的访问
  21.         // 输出“粤菜白斩鸡”，“粤菜清蒸鱼”
  22.         obj.accept(gdCook);
  23.         // 输出”川菜辣子鸡“，”川菜水煮鱼“
  24.         obj.accept(scCook);
  25.     }
  27. }
  28. /**
  29.  * 抽象访问者
  30.  * 定义对所有访问对象的抽象访问方法，参数是所要访问的对象。
  31.  * 下例抽象访问者为厨师，访问对象是鸡和鱼。
  32.  */
  33. abstract class Cook{
  34.     public abstract void make(ChickenMaterial chicken);
  35.     public abstract void make(FishMaterial fish);
  36. }
  38. /**
  39.  * 具体访问者
  40.  * 继承抽象访问者类，实现抽象方法。
  41.  * 下例是广东厨师访问鸡和鱼的动作,分别处理为粤菜白斩鸡和粤菜清蒸鱼。
  42.  */
  43. class GuangdongCook extends Cook {
  44.     @Override
  45.     public void make(ChickenMaterial chicken) {
  46.         System.out.println("粤菜白斩鸡");
  47.     }
  48.     @Override
  49.     public void make(FishMaterial fish) {
  50.         System.out.println("粤菜清蒸鱼");
  51.     }
  52. }
  54. /**
  55.  * 具体访问者
  56.  * 下例是四川厨师访问鸡和鱼的动作，分别处理为川菜辣子鸡和川菜水煮鱼。
  57.  */
  58. class SichuanCook extends Cook {
  59.     @Override
  60.     public void make(ChickenMaterial chicken) {
  61.         System.out.println("川菜辣子鸡");
  62.     }
  63.     @Override
  64.     public void make(FishMaterial fish) {
  65.         System.out.println("川菜水煮鱼");
  66.     }
  67. }
  69. /**
  70.  * 抽象访问对象
  71.  * 定义抽象访问方法accept(Cook cook)，用于接受一个具体的访问者类的访问。
  72.  */
  73. abstract class Material{
  74.     public abstract void accept(Cook cook);
  75. }
  77. /**
  78.  * 具体访问对象
  79.  * 实现抽象类中的抽象方法accept(Cook cook)。传入具体访问者，调用访问者
  80.  * 的行为方法(传入此时的访问对象指针this)。
  81.  */
  82. class ChickenMaterial extends Material{
  83.     @Override
  84.     public void accept(Cook cook) {
  85.         cook.make(this);
  86.     }
  87. }
  89. /**
  90.  * 具体访问对象
  91.  */
  92. class FishMaterial extends Material{
  93.     public void accept(Cook cook) {
  94.         cook.make(this);
  95.     }
  96. }
  98. /**
  99.  * 访问对象结构类
  100.  * 持有访问对象的集合List<Material>，管理访问对象，有增加访问对象方法add，
  101.  * 移除访问对象方法remove，执行访问者对访问对象的访问动作accept方法。该
  102.  * 方法内用for-each遍历该结构类持有的访问对象集合，并对每一个访问对象执行
  103.  * 其accpet方法。
  104.  */
  105. class ObjectStructure{
  106.     private List<Material> materials = new ArrayList<>();
  108.     public void add(Material material) {
  109.         if(!materials.contains(material)){
  110.             materials.add(material);
  111.         }
  112.     }
  113.     public void remove(Material material) {
  114.         if(materials.contains(material)) {
  115.             materials.remove(material);
  116.         }
  117.     }
  118.     public void accept(Cook cook) {
  119.         for(Material m : materials) {
  120.             m.accept(cook);
  121.         }
  122.     }
  123. }