PHP面向对象程序设计组合模式与装饰模式详解

本文实例讲述了PHP面向对象程序设计组合模式与装饰模式。分享给大家供大家参考，具体如下：
组合模式
定义：组合模式定义了一个单根继承体系，使具有截然不同职责的集合可以并肩工作。
一个军队的案例，

<?phpabstract class Unit { // 个体abstract function bombardStrength（）;}class Archer extends Unit { // 弓箭手function bombardStrength（） {return 4;}}class LaserCannonUnit extends Unit { // 火炮手function bombardStrength（） {return 44;}}?>

军队整合成员，输出火力

<?phpabstract class Unit {abstract function bombardStrength（）;}class Archer extends Unit {function bombardStrength（） {return 4;}}class LaserCannonUnit extends Unit {function bombardStrength（） {return 44;}}class Army { // 军队private $units = array（）; // 定义私有属性 个体集function addUnit（ Unit $unit ） { // 添加成员array_push（ $this->units, $unit ）;}function bombardStrength（） { // 火力$ret = 0;foreach（ $this->units as $unit ） {$ret += $unit->bombardStrength（）;}return $ret;}}$unit1 = new Archer（）;$unit2 = new LaserCannonUnit（）;$army = new Army（）;$army->addUnit（ $unit1 ）;$army->addUnit（ $unit2 ）;print $army->bombardStrength（）; // 输出火力?>

output:
48
军队进一步整合其他军队

<?phpabstract class Unit {abstract function bombardStrength（）;}class Archer extends Unit {function bombardStrength（） {return 4;}}class LaserCannonUnit extends Unit {function bombardStrength（） {return 44;}}class Army {private $units = array（）;private $armies= array（）;function addUnit（ Unit $unit ） {array_push（ $this->units, $unit ）;}function addArmy（ Army $army ） {array_push（ $this->armies, $army ）;}function bombardStrength（） {$ret = 0;foreach（ $this->units as $unit ） {$ret += $unit->bombardStrength（）;}foreach（ $this->armies as $army ） {$ret += $army->bombardStrength（）;}return $ret;}}$unit1 = new Archer（）;$unit2 = new LaserCannonUnit（）;$army = new Army（）;$army->addUnit（ $unit1 ）;$army->addUnit（ $unit2 ）;print $army->bombardStrength（）;print "
";$army2 = clone $army; // 克隆军队$army->addArmy（ $army2 ）;print $army->bombardStrength（）;print "
";?>

output:
48
96
更好的方式，支持新增，移除等等其他功能。

<?phpabstract class Unit {abstract function addUnit（ Unit $unit ）;abstract function removeUnit（ Unit $unit ）;abstract function bombardStrength（）;}class Army extends Unit { // 军队private $units = array（）;function addUnit（ Unit $unit ） {if （ in_array（ $unit, $this->units, true ） ） { // $this用于调用正常的属性或方法，self调用静态的方法，属性或者常量return;}$this->units[] = $unit;}function removeUnit（ Unit $unit ） {// >= php 5.3$this->units = array_udiff（ $this->units, array（ $unit ）,function（ $a, $b ） { return （$a === $b）?0:1; } ）;// < php 5.3// $this->units = array_udiff（ $this->units, array（ $unit ）,//create_function（ "$a,$b", "return （$a === $b）?0:1;" ） ）;// 对象数组，create_function,创建函数}function bombardStrength（） {$ret = 0;foreach（ $this->units as $unit ） {$ret += $unit->bombardStrength（）;}return $ret;}}// quick example classesclass Tank extends Unit { // 坦克function addUnit（ Unit $unit ） {}function removeUnit（ Unit $unit ） {}function bombardStrength（） {return 4;}}class Soldier extends Unit { // 士兵function addUnit（ Unit $unit ） {}function removeUnit（ Unit $unit ） {}function bombardStrength（） {return 8;}}$tank = new Tank（）;$tank2 = new Tank（）;$soldier = new Soldier（）;$army = new Army（）;$army->addUnit（ $soldier ）;$army->addUnit（ $tank ）;$army->addUnit（ $tank2 ）;print_r（ $army ）;print $army->bombardStrength（）."
";$army->removeUnit（ $soldier ）;print_r（ $army ）;print $army->bombardStrength（）."
";?>

output:

Army Object（[units:Army:private] => Array（[0] => Soldier Object（）[1] => Tank Object（）[2] => Tank Object（）））16Army Object（[units:Army:private] => Array（[1] => Tank Object（）[2] => Tank Object（）））8

添加异常处理

<?phpabstract class Unit {abstract function addUnit（ Unit $unit ）;abstract function removeUnit（ Unit $unit ）;abstract function bombardStrength（）;}class Army extends Unit {private $units = array（）;function addUnit（ Unit $unit ） {if （ in_array（ $unit, $this->units, true ） ） {return;}$this->units[] = $unit;}function removeUnit（ Unit $unit ） {// >= php 5.3//$this->units = array_udiff（ $this->units, array（ $unit ）,//function（ $a, $b ） { return （$a === $b）?0:1; } ）;// < php 5.3$this->units = array_udiff（ $this->units, array（ $unit ）,create_function（ "$a,$b", "return （$a === $b）?0:1;" ） ）;}function bombardStrength（） {$ret = 0;foreach（ $this->units as $unit ） {$ret += $unit->bombardStrength（）;}return $ret;}}class UnitException extends Exception {}class Archer extends Unit {function addUnit（ Unit $unit ） {throw new UnitException（ get_class（$this）." is a leaf" ）;}function removeUnit（ Unit $unit ） {throw new UnitException（ get_class（$this）." is a leaf" ）;}function bombardStrength（） {return 4;}}$archer = new Archer（）;$archer2 = new Archer（）;$archer->addUnit（ $archer2 ）;?>

output:
Fatal error: Uncaught exception "UnitException" with message "Archer is a leaf"
点评：组合模式中的一切类都共享同一个父类型，可以轻松地在设计中添加新的组合对象或局部对象，而无需大范围地修改代码。
最终的效果，逐步优化（完美）：

<?phpclass UnitException extends Exception {}abstract class Unit {abstract function bombardStrength（）;function addUnit（ Unit $unit ） {throw new UnitException（ get_class（$this）." is a leaf" ）;}function removeUnit（ Unit $unit ） {throw new UnitException（ get_class（$this）." is a leaf" ）;}}class Archer extends Unit {function bombardStrength（） {return 4;}}class LaserCannonUnit extends Unit {function bombardStrength（） {return 44;}}class Army extends Unit {private $units = array（）;function addUnit（ Unit $unit ） {if （ in_array（ $unit, $this->units, true ） ） {return;}$this->units[] = $unit;}function removeUnit（ Unit $unit ） {// >= php 5.3//$this->units = array_udiff（ $this->units, array（ $unit ）,//function（ $a, $b ） { return （$a === $b）?0:1; } ）;// < php 5.3$this->units = array_udiff（ $this->units, array（ $unit ）,create_function（ "$a,$b", "return （$a === $b）?0:1;" ） ）;}function bombardStrength（） {$ret = 0;foreach（ $this->units as $unit ） {$ret += $unit->bombardStrength（）;}return $ret;}}// create an army$main_army = new Army（）;// add some units$main_army->addUnit（ new Archer（） ）;$main_army->addUnit（ new LaserCannonUnit（） ）;// create a new army$sub_army = new Army（）;// add some units$sub_army->addUnit（ new Archer（） ）;$sub_army->addUnit（ new Archer（） ）;$sub_army->addUnit（ new Archer（） ）;// add the second army to the first$main_army->addUnit（ $sub_army ）;// all the calculations handled behind the scenesprint "attacking with strength: {$main_army->bombardStrength（）}
";?>

output:
attacking with strength: 60
更牛逼的组合处理，

<?phpabstract class Unit {function getComposite（） {return null;}abstract function bombardStrength（）;}abstract class CompositeUnit extends Unit { // 抽象类继承抽象类private $units = array（）;function getComposite（） {return $this;}protected function units（） {return $this->units;}function removeUnit（ Unit $unit ） {// >= php 5.3//$this->units = array_udiff（ $this->units, array（ $unit ）,//function（ $a, $b ） { return （$a === $b）?0:1; } ）;// < php 5.3$this->units = array_udiff（ $this->units, array（ $unit ）,create_function（ "$a,$b", "return （$a === $b）?0:1;" ） ）;}function addUnit（ Unit $unit ） {if （ in_array（ $unit, $this->units, true ） ） {return;}$this->units[] = $unit;}}class Army extends CompositeUnit {function bombardStrength（） {$ret = 0;foreach（ $this->units as $unit ） {$ret += $unit->bombardStrength（）;}return $ret;}}class Archer extends Unit {function bombardStrength（） {return 4;}}class LaserCannonUnit extends Unit {function bombardStrength（） {return 44;}}class UnitScript {static function joinExisting（ Unit $newUnit, Unit $occupyingUnit ） { // 静态方法，直接通过类名来使用$comp;if （ ！ is_null（ $comp = $occupyingUnit->getComposite（） ） ） { // 军队合并处理$comp->addUnit（ $newUnit ）;} else { // 士兵合并处理$comp = new Army（）;$comp->addUnit（ $occupyingUnit ）;$comp->addUnit（ $newUnit ）;}return $comp;}}$army1 = new Army（）;$army1->addUnit（ new Archer（） ）;$army1->addUnit（ new Archer（） ）;$army2 = new Army（）;$army2->addUnit（ new Archer（） ）;$army2->addUnit（ new Archer（） ）;$army2->addUnit（ new LaserCannonUnit（） ）;$composite = UnitScript::joinExisting（ $army2, $army1 ）;print_r（ $composite ）;?>

output:

Army Object（[units:CompositeUnit:private] => Array（[0] => Archer Object（）[1] => Archer Object（）[2] => Army Object（[units:CompositeUnit:private] => Array（[0] => Archer Object（）[1] => Archer Object（）[2] => LaserCannonUnit Object（）））））

点评：Unit 基础，CompositeUnit复合中实现add与remove。军队继承Composite，射手继承Archer。这样射手中就不会有多余的add与remove方法了。
装饰模式
装饰模式帮助我们改变具体组件的功能。
看例子

<?phpabstract class Tile { // 砖瓦abstract function getWealthFactor（）; // 获取财富}class Plains extends Tile { // 平原private $wealthfactor = 2;function getWealthFactor（） {return $this->wealthfactor;}}class DiamondPlains extends Plains { // 钻石地段function getWealthFactor（） {return parent::getWealthFactor（） + 2;}}class PollutedPlains extends Plains { // 污染地段function getWealthFactor（） {return parent::getWealthFactor（） - 4;}}$tile = new PollutedPlains（）;print $tile->getWealthFactor（）;?>

output:
-2
点评：不具有灵活性，我们不能同时获得钻石与被污染的土地的资金情况。
装饰模式使用组合和委托而不是只使用继承来解决功能变化的问题。
看例子：

<?phpabstract class Tile {abstract function getWealthFactor（）;}class Plains extends Tile {private $wealthfactor = 2;function getWealthFactor（） {return $this->wealthfactor;}}abstract class TileDecorator extends Tile { // 装饰protected $tile;function __construct（ Tile $tile ） {$this->tile = $tile;}}class DiamondDecorator extends TileDecorator { // 钻石装饰function getWealthFactor（） {return $this->tile->getWealthFactor（）+2;}}class PollutionDecorator extends TileDecorator { // 污染装饰function getWealthFactor（） {return $this->tile->getWealthFactor（）-4;}}$tile = new Plains（）;print $tile->getWealthFactor（）; // 2$tile = new DiamondDecorator（ new Plains（） ）;print $tile->getWealthFactor（）; // 4$tile = new PollutionDecorator（ new DiamondDecorator（ new Plains（） ））;print $tile->getWealthFactor（）; // 0?>

output:
2
4
0
点评：这个模型具有扩展性。我们不需要创建DiamondPollutionPlains对象就可以构建一个钻石被污染的对象。
一个更逼真的例子

<?phpclass RequestHelper{} // 请求助手abstract class ProcessRequest { // 进程请求abstract function process（ RequestHelper $req ）;}class MainProcess extends ProcessRequest { // 主进程function process（ RequestHelper $req ） {print __CLASS__.": doing something useful with request
";}}abstract class DecorateProcess extends ProcessRequest { // 装饰进程protected $processrequest;function __construct（ ProcessRequest $pr ） { // 引用对象，委托$this->processrequest = $pr;}}class LogRequest extends DecorateProcess { // 日志请求function process（ RequestHelper $req ） {print __CLASS__.": logging request
"; // 当前类,有点递归的感觉$this->processrequest->process（ $req ）;}}class AuthenticateRequest extends DecorateProcess { // 认证请求function process（ RequestHelper $req ） {print __CLASS__.": authenticating request
";$this->processrequest->process（ $req ）;}}class StructureRequest extends DecorateProcess { // 组织结构请求function process（ RequestHelper $req ） {print __CLASS__.": structuring request
";$this->processrequest->process（ $req ）;}}$process = new AuthenticateRequest（ new StructureRequest（new LogRequest （new MainProcess（））））; // 这样可以很灵活的组合进程的关系，省去很多重复的继承$process->process（ new RequestHelper（） ）;print_r（$process）;?>

output:

AuthenticateRequest: authenticating requestStructureRequest: structuring requestLogRequest: logging requestMainProcess: doing something useful with requestAuthenticateRequest Object（[processrequest:protected] => StructureRequest Object（[processrequest:protected] => LogRequest Object（[processrequest:protected] => MainProcess Object（））））

点评：这里有一种递归的感觉，一层调用一层。模式是牛人总结出来用于灵活的解决一些现实问题的。牛！给开发多一点思路。
更多关于PHP相关内容感兴趣的读者可查看本站专题：《php面向对象程序设计入门教程》、《PHP基本语法入门教程》、《PHP运算与运算符用法总结》、《PHP网络编程技巧总结》、《PHP数组（Array）操作技巧大全》、《php字符串（string）用法总结》、《php+mysql数据库操作入门教程》及《php常见数据库操作技巧汇总》
希望本文所述对大家PHP程序设计有所帮助。