十一、访问者模式（行为型模式）

使用这个模式后就可以在不修改已有程序结构的前提下，通过添加额外的“访问者”来完成对已有代码功能的提升

表示一个作用于某对象结构中的各元素的操作。它使你可以在不改变各元素的类的前提下定义作用于这些元素的新操作。 

特点

访问者模式把数据结构和作用于结构上的操作解耦合，使得操作集合可相对自由地演化。

访问者模式适用于数据结构相对稳定算法又易变化的系统。因为访问者模式使得算法操作增加变得容易。若系统数据结构对象易于变化，经常有新的数据对象增加进来，则不适合使用访问者模式。

访问者模式的优点是增加操作很容易，因为增加操作意味着增加新的访问者。访问者模式将有关行为集中到一个访问者对象中，其改变不影响系统数据结构。其缺点就是增加新的数据结构很困难。

优点

1、符合单一职责原则：凡是适用访问者模式的场景中，元素类中需要封装在访问者中的操作必定是与元素类本身关系不大且是易变的操作，使用访问者模式一方面符合单一职责原则，另一方面，因为被封装的操作通常来说都是易变的，所以当发生变化时，就可以在不改变元素类本身的前提下，实现对变化部分的扩展。

2、扩展性良好：元素类可以通过接受不同的访问者来实现对不同操作的扩展。

适用情况

1、 一个对象结构包含很多类对象，它们有不同的接口，而你想对这些对象实施一些依赖于其具体类的操作。

2、 需要对一个对象结构中的对象进行很多不同的并且不相关的操作，而你想避免让这些操作“污染”这些对象的类。Visitor模式使得你可以将相关的操作集中起来 定义在一个类中。

3、 当该对象结构被很多应用共享时，用Visitor模式让每个应用仅包含需要用到的操作。

4)、定义对象结构的类很少改变，但经常需要在此结构上定义新的操作。改变对象结构类需要重定义对所有访问者的接口，这可能需要很大的代价。如果对象结构类经常改变，那么可能还是在这些类中定义这些操作较好。

这是一个比较巧妙而且复杂的模式，它的使用条件比较苛刻，当系统中存在着固定的数据结构（比如下面的类层次），而且有着不同的行为，那么访问者模式也许是个不错的选择。

双重分派

首先在客户程序中将具体访问者作为参数传递给具体元素角色。这便完成了一次分派。进入具体元素角色后，具体元素角色调用作为参数的的具体访问者中的Visitor方法，同时将自己(this)作为参数传递进去。具体访问者在根据参数的不同来选择方法来执行。这便完成了第二次分派。

访问者角色

interface Visitor {
   void visit(Gladiolus g);
   void visit(Runuculus r);
   void visit(Chrysanthemum c);
}

元素角色

interface Flower {
   void accept(Visitor v);
}

三个具体的元素角色

class Gladiolus implements Flower {
   @Override
   public void accept(Visitor v) {
      v.visit(this);
   }
}

class Chrysanthemum implements Flower {
   @Override
   public void accept(Visitor v) {
      v.visit(this);
   }
}

class Runuculus implements Flower {
   @Override
   public void accept(Visitor v) {
      v.visit(this);
   }
}

实现具体访问者角色

class StringVal implements Visitor {
   String s;
   public String toString() {
      return s;
   }
   @Override
   public void visit(Gladiolus g) {
      s = "Gladiolus";
   }
   @Override
   public void visit(Runuculus r) {
      s = "Runuculus";
   }
   @Override
   public void visit(Chrysanthemum c) {
      s = "Chrysanthemum";
   }
}

实现另一个访问者

class Bee implements Visitor {
   @Override
   public void visit(Gladiolus g) {
      System.out.println("Bee Gladiolus");
   }
   @Override
   public void visit(Runuculus r) {
      System.out.println("Bee Runuculus");
   }
   @Override
   public void visit(Chrysanthemum c) {
      System.out.println("Bee Chrysanthemum");
   }
}

一个对象生成器

class FlowerGenerator {
   private static Random rand = new Random();
   public static Flower newFlower() {
      switch (rand.nextInt(3)) {
      case 0:
        return new Gladiolus();
      case 2:
        return new Runuculus();
      case 1:
        return new Chrysanthemum();
      default:
        break;
      }
      return null;
   }
}

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import java.util.Random;
public class Client {
   public static void main(String[] args) {
      List<Flower> flowers = new ArrayList<Flower>();
      for (int i = 0; i < 10; i++) {
        flowers.add(FlowerGenerator.newFlower());
      }
      Visitor visitor = new StringVal();
      // 这个地方你可以修改以便使用另外一个具体实现分访问者角色
      for (Iterator iterator = flowers.iterator(); iterator.hasNext();) {
        Flower flower = (Flower) iterator.next();
        flower.accept(visitor);
        System.out.println(visitor);
      }
      System.out.println("===========");
      visitor = new Bee();
      for (Iterator iterator = flowers.iterator(); iterator.hasNext();) {
        Flower flower = (Flower) iterator.next();
        flower.accept(visitor);
      }
/**
Gladiolus
Chrysanthemum
Gladiolus
Chrysanthemum
Runuculus
Chrysanthemum
Gladiolus
Chrysanthemum
Chrysanthemum
Chrysanthemum
===========
Bee Gladiolus
Bee Chrysanthemum
Bee Gladiolus
Bee Chrysanthemum
Bee Runuculus
Bee Chrysanthemum
Bee Gladiolus
Bee Chrysanthemum
Bee Chrysanthemum
Bee Chrysanthemum
 *
 */
   }
}