大话设计模式-访问者模式

引自原书

1.访问者模式适用于数据结构相对稳定的系统

2.它把数据结构和作用于结构之上的操作之间的耦合解脱开，使得操作集合可以相对自由的演化

3.访问者模式的目的是要把处理从数据结构分离出来

4.有比较稳定的数据结构，又有易于变化的算法的话，使用访问者模式就是比较合适的，因为访问者模式使得算法操作的增加变得容易。

5.访问者模式的优点就是增加新的操作很容易，因为增加新的操作就意味着增加一个新的访问者。访问者模式将有关的行为集中到一个访问者对象中。

6.访问者的缺点就是使得增加新的数据结构变得困难了

大多数时候你并不需要访问者模式。我们很难找到数据结构不变化的情况

abstract class Action {
 //得到男人结论或反应
 public abstract function getManConclusion(Man $concreteElementA);


 //得到女人结论或反应
 public abstract function getWomanConclusion(Woman $concreteElementB);
}


abstract class Person {
 //接受（它是用来获得‘状态’对象的）
 public abstract function accept(Action $visitor);
}


//成功
class Success extends Action {
 public function getManConclusion(Man $concreteElementA) {
  echo get_class($concreteElementA).' '.get_class($this).'时，背后大多有一个伟大的女人。<br/>';
 }


 public function getWomanConclusion(Woman $concreteElementB) {
  echo get_class($concreteElementB).' '.get_class($this).'时，背后大多有一个不成功的男人。<br/>';
 }
}


//失败
class Failing extends Action {
 public function getManConclusion(Man $concreteElementA) {
  echo get_class($concreteElementA).' '.get_class($this).'时,闷头喝酒，谁也不用劝。<br/>';
 }


 public function getWomanConclusion(Woman $concreteElementB) {
  echo get_class($concreteElementB).' '.get_class($this).'时，眼泪汪汪，谁也劝不了。<br/>';
 }
}


//恋爱
class Amativeness extends Action {
 public function getManConclusion(Man $concreteElementA) {
  echo get_class($concreteElementA).' '.get_class($this).'时,凡事不懂也要装懂。<br/>';
 }


 public function getWomanConclusion(Woman $concreteElementB) {
  echo get_class($concreteElementB).' '.get_class($this).'时，遇事也装作不懂。<br/>';
 }
}

//结婚
class Marriage extends Action {
 public function getManConclusion(Man $concreteElementA) {
  echo get_class($concreteElementA).' '.get_class($this).'时,感慨道：恋爱游戏终结时，‘有妻徒刑’遥无期。<br/>';
 }


 public function getWomanConclusion(Woman $concreteElementB) {
  echo get_class($concreteElementB).' '.get_class($this).'时，欣慰曰：爱情长跑路漫漫，婚姻保险保平安。<br/>';
 }
}


//男人
class Man extends Person {
 public function accept(Action $visitor) {
  //首先在客户程序中将具体状态作为参数传递给‘男人’类完成了一次分派，然后‘男人’类调用作为参数的‘具体状态’中的方法‘男人反应’，同时将自己(this)作为参数传递进去。这便完成了第二次分派
  $visitor->getManConclusion($this);
 }
}


//女人
class Woman extends Person {
 public function accept(Action $visitor) {
  $visitor->getWomanConclusion($this);
 }
}


//对象结构
class ObjectStructure {
 private $elements;


 //增加
 public function attach(Person $element) {
  $this->elements[] = $element;
 }


 //移动
 public function detach(Person $element) {
  unset($this->elements[array_search($element, $this->elements)]);
 }


 //查看显示(遍历方法)
 public function display(Action $visitor) {
  foreach($this->elements as $e) {
   $e->accept($visitor);
  }
 }
}


$o = new ObjectStructure();
//在对象结构中加入要对比的‘男人’和‘女人’
$o->attach(new Man());
$o->attach(new Woman());


//成功时的反应
$v1 = new Success();
//查看在各种状态下，‘男人’和‘女人’的反应
$o->display($v1);


//失败时的反应
$v2 = new Failing();
$o->display($v2);


//恋爱时的反应
$v3 = new Amativeness();
$o->display($v3);


//结婚时的反应
$v4 = new Marriage();
$o->display($v4);

访问者模式

//为对象结构中ConcreteElement的每一个类声明一个Visit操作
abstract class Visitor {
 public abstract function visitConcreteElementA(ConcreteElementA $concreteElementA);
 public abstract function visitConcreteElementB(ConcreteElementB $concreteElementB);
}

//ConcreteVisitor1和ConcreteVisitor2类，具体访问者，实现每个由visitor声明的操作。每个操作实现算法的一部分，而该算法片断乃是对应于结构中对象的类。
class ConcreteVisitor1 extends Visitor {
 public function visitConcreteElementA(ConcreteElementA $concreteElementA) {
  echo get_class($concreteElementA).'被'.get_class($this).'访问1<br/>';
 }
 public function visitConcreteElementB(ConcreteElementB $concreteElementB) {
  echo get_class($concreteElementB).'被'.get_class($this).'访问1<br/>';
 }
}

class ConcreteVisitor2 extends Visitor {
 public function visitConcreteElementA(ConcreteElementA $concreteElementA) {
  echo get_class($concreteElementA).'被'.get_class($this).'访问2<br/>';
 }
 public function visitConcreteElementB(ConcreteElementB $concreteElementB) {
  echo get_class($concreteElementB).'被'.get_class($this).'访问2<br/>';
 }
}

//定义一个accept操作，它以一个访问者为参数。
abstract class Element {
 public abstract function Accept(Visitor $visitor);
}

//ConcreteElementA和ConcreteElementB类，具体元素，实现accept操作
class ConcreteElementA extends Element {
 //充分利用双分派技术，实现处理与数据结构的分离
 public function accept(Visitor $visitor) {
  $visitor->visitConcreteElementA($this);
 }
 //其他相关方法
 public function operationA(){
 }
}

class ConcreteElementB extends Element {
 //充分利用双分派技术，实现处理与数据结构的分离
 public function accept(Visitor $visitor) {
  $visitor->visitConcreteElementB($this);
 }
 //其他相关方法
 public function operationB(){
 }
}

//能枚举它的元素，可以提供一个高层的接口允许访问者访问它的元素。
class ObjectStructure {
 private $elements;

 public function attach(Element $element) {
  $this->elements[] = $element;
 }

 public function detach(Element $element) {
  $this->elements[] = $element;
 }

 public function accept(Visitor $visitor) {
  foreach($this->elements as $e) {
   $e->accept($visitor);
  }
 }
}

$o = new ObjectStructure();
$o->attach(new ConcreteElementA());
$o->attach(new ConcreteElementB());
$v1 = new ConcreteVisitor1();
$v2 = new ConcreteVisitor2();

$o->accept($v1);
$o->accept($v2);