查看: 1068|回复: 0

[PHP学习] 浅谈PHP面向对象之访问者模式+组合模式

发表于 2018-3-31 08:00:03

因为原文中延续了组合模式的代码示例来讲访问者模式 所以这里就合并一起来复习了。但主要还是讲访问者模式。顾名思义这个模式会有一个访问者类(就像近期的热播剧“人民的名义”中的检查官,跑到到贪官家里调查取证,查实后就定罪),被访问者类调用访问者类的时候会将自身传递给它使用。

直接看代码:

  1. //被访问者基类
  2. abstract class Unit {
  3.   abstract function bombardStrength();  //获取单位的攻击力
  4.   
  5.   //这个方法将调用访问者类,并将自身传递给它
  6.   function accept(ArmyVisitor $visitor){
  7.     $method = "visit" . get_class($this);
  8.     $visitor->$method($this);      //调用访问者类的方法,这里使用了 "visit" . get_class($this) 组成了方法的名称
  9.   }
  10.   
  11.   //按原文的说法是设置一个深度,虽然之后会有调用但这个方法对于理解这个模式不重要可以不用管他(原文示例代码中经常有些跟理解模式原理没太多关系的代码)
  12.   protected function setDepth($depth){
  13.     $this->depth = $depth;
  14.   }
  15.   function getDepth(){
  16.     return $this->depth;
  17.   }
  18. }
  19. //弓箭手
  20. class Archer extends Unit{
  21.   function bombardStrength(){
  22.     return 4;
  23.   }
  24. }
  25. //激光炮
  26. class LaserCannonUnit extends Unit{
  27.   function bombardStrength(){
  28.     return 44;
  29.   }
  30. }
  31. //骑兵
  32. class Cavalry extends Unit{
  33.   function bombardStrength(){
  34.     return 2;          //骑兵的攻击力居然比弓箭手低?
  35.   }
  36. }
  37. //用于组合继承了unit类的实例,并让Army和TroopCarrier类继承removeUnit和addUnit方法,不放基类是因为上述的三个类已经是最小单位了不是一个军事集团removeUnit和addUnit方法对他们没用。
  38. abstract class CompositeUnit extends Unit{
  39.   private $units = array();    //存放任何继承了unit 类的实例
  40.   function getComposite(){   //这个方法主要用于判断当前实例是否是一个 CompositeUnit 类
  41.     return $this;
  42.   }
  43.   protected function units(){
  44.     return $this->units;
  45.   }
  46.   function removeUnit(Unit $unit){    //删除一个军事单位
  47.     $this->units = array_udiff(
  48.       $this->units,array($unit),
  49.       function($a,$b){return ($a === $b)?0:1;}
  50.     );  
  51.   }
  52.   function addUnit(Unit $unit){        //添加一个军事单位
  53.     if(in_array($unit,$this->units,true)){
  54.       return;
  55.     }
  56.     $unit->setDepth($this->depth + 1);  
  57.     $this->units[] = $unit;
  58.   }
  59.   function bombardStrength(){
  60.     $ret = 0;
  61.     foreach($this->units as $unit){
  62.       $ret +=$unit->bombardStrength();
  63.     }
  64.     return $ret;
  65.   }
  66.   function accept(Armyvisitor $visitor){    //调用访问者
  67.     parent::accept($visitor);        //调用基类的accept方法,在第一个客户端代码条用里将会保存军事集团整体的一个信息
  68.     foreach($this->units as $thisunit){   //调用军事单位accept方法,在第一个客户端代码条用里将会保存其中每一个军事单位的信息
  69.       $thisunit->accept($visitor);
  70.     }
  71.   }
  72. }
  73. //军队
  74. class Army extends CompositeUnit {
  75. }
  76. //舰队
  77. class TroopCarrier extends CompositeUnit {
  78. }
  79. //访问者类
  80. abstract class ArmyVisitor{
  81.   abstract function visit(Unit $node);  //访问者要执行的业务逻辑
  82.   function visitArcher(Archer $node){  //其实我觉得对于理解来说这个抽象类有一个抽象方法visit()就够了,原文还多出下面这些方法来绕个圈调用visit
  83.     //......
  84.     $this->visit($node);
  85.   }
  86.   function visitCavalry(Cavalry $node){
  87.     //.......
  88.     $this->visit($node);
  89.   }
  90.   function visitLaserCannonUnit(LaserCannonUnit $node){
  91.     //......
  92.     $this->visit($node);
  93.   }
  94.   function visitTroopCarrierUnit(Cavalry $node){
  95.     //......
  96.     $this->visit($node);
  97.   }
  98.   function visitArmy(Cavalry $node){
  99.     //......
  100.     $this->visit($node);
  101.   }
  102. }
  103. //这个访问者类主要用于获取并保存被访问者对象的信息
  104. class TextDumpArmyVisitor extends ArmyVisitor {
  105.   private $text = "";
  106.   function visit(Unit $node){
  107.     $ret = "";
  108.     $pad = 4 * $node->getDpth();
  109.     $ret .= sprintf("%{$pad}s","");
  110.     $ret .=get_class($node).": ";
  111.     $ret .= "bombard: " . $node->bombardStrength() . "\n";
  112.     $this->text .=$ret;
  113.   }
  114.   function getText(){
  115.     return $this->text;
  116.   }
  117. }
  118. //用于向每个对象征税的访问者类,客户端代码2中将会调用
  119. class TaxCollectionVisitor extends ArmyVisitor{
  120.   private $due=0;
  121.   private $report ="";
  122.   function visit(Unit $node){
  123.     $this->levy($node,1);
  124.   }
  125.   function visitArcher(Archer $node){    //复写了父类的方法,对于不同的单位征收不同的税
  126.     $this->levy($node,2);
  127.   }
  128.   function visitCavalry(Cavalry $node){
  129.     $this->levy($node,3);
  130.   }
  131.   function visitTroopCarrierUnit(TroopCarrierUnit $node){
  132.     $this->levy($node,5);
  133.   }
  134.   private function levy(Unit $unit,$amount){        //主要的业务逻辑
  135.     $this->report .= "Tax levied for" . get_class($unit);
  136.     $this->report .= ": $amount\n";
  137.     $this->due +=$amount;
  138.   }
  139.   function getReport(){
  140.     return $this->report;
  141.   }
  142.   function getTax(){
  143.     return $this->due;
  144.   }
  145. }
  146. //客户端代码1(获取并输出每个对象的一些信息)
  147. class UnitScript {
  148.   static function joinExisting(Unit $newUnit,Unit $occupyingUnit){
  149.     $comp;
  150.     if(!is_null($com = $occupyingUnit->getComposite())){
  151.       $comp->addUnit($newUnit);
  152.     } else {
  153.       $comp = new Army();
  154.       $comp->addUnit($occupyingUnit);
  155.       $com->addUnit($newUnit);
  156.     }
  157.     return $comp;
  158.   }
  159. }
  160. $main_army = new Army();
  161. UnitScript::joinExisting(new Archer(),$main_army);
  162. UnitScript::joinExisting(new LaserCannonUnit(),$main_army);
  163. UnitScript::joinExisting(new Cavalry(),$main_army);
  164. $textdump = new TextDumpArmyVisitor();
  165. $main_army->accept($textdump);
  166. print $textdump->getText();
  167. //客户端代码2(对每个对象征税,最后输出总共征收了多少)
  168. $main_army = new Army();
  169. UnitScript::joinExisting(new Archer(),$main_army);
  170. UnitScript::joinExisting(new LaserCannonUnit(),$main_army);
  171. UnitScript::joinExisting(new Cavalry(),$main_army);
  172. $taxcollector = new TaxCollectionVisitor();
  173. $main_army->accept($taxcollector);
  174. print $taxcollector->getTax();
  175.     //上述的代码因为太懒没测试,抱歉! 感兴趣的朋友就自己运行调试一下吧!
复制代码

以上这篇浅谈PHP面向对象之访问者模式+组合模式就是小编分享给大家的全部内容了,希望能给大家一个参考,也希望大家多多支持程序员之家。



回复

使用道具 举报