首页
编程开发 > PHP > 文章内容

PHP教程：浅谈PHP面向对象之访问者模式+组合模式

2017-6-28编辑:daibenhua

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

　　直接看代码：

　　?

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

　　以上这篇浅谈PHP面向对象之访问者模式+组合模式就是小编分享给大家的全部内容了

PHP教程：phpreadfile下载大文件失败的解决方法

热点推荐

登录注册
触屏版电脑版网站地图