第六章 穿什么有这么重要吗 －－－ 装饰模式

  1. <?php
  3. abstract class Component
  4. {
  5.     abstract public function Operation();
  6. }
  8. /**
  9. * ConcreteComponent
  10. */
  11. class ConcreteComponent extends Component
  12. {
  13.     public function Operation()
  14.     {
  15.         echo "具体对象的操作.\n";
  16.     }
  17. }
  19. abstract class Decorator extends Component
  20. {
  21.     protected $component;
  23.     // 设置component
  24.     public function SetComponent($component)
  25.     {
  26.         $this->component = $component;
  27.     }
  29.     // 重写Operation(),实际执行的是component的Operation方法
  30.     public function Operation()
  31.     {
  32.         if ($this->component != null)
  33.         {
  34.             $this->component->Operation();
  35.         }
  36.     }
  37. }
  39. /**
  40. * ConcreteDecoratorA
  41. */
  42. class ConcreteDecoratorA extends Decorator
  43. {
  44.     // 本类的独有功能，以区别于ConcreteDecoratorB
  45.     private $addedState;
  47.     public function Operation()
  48.     {   
  49.         // 首先运行原Component的Operation(),再执行本类的功能，
  50.         // 如addedState,相当于对原Component进行了装饰
  51.         parent::Operation();
  52.         $this->addedState = "ConcreteDecoratorA Status";
  53.         echo $this->addedState."\n";
  54.         echo "具体装饰对象A的操作.\n";
  55.     }
  56. }
  59. /**
  60. * ConcreteDecoratorB
  61. */
  62. class ConcreteDecoratorB extends Decorator
  63. {
  64.     public function Operation()
  65.     {   
  66.         // 首先运行原Component的Operation(),再执行本类的功能，
  67.         // 如addedBehavior,相当于对原Component进行了装饰
  68.         parent::Operation();
  69.         $this->addedBehavior();
  70.         echo "具体装饰对象B的操作.\n";
  71.     }
  73.     // 本类的独有功能，以区别于ConcreteDecoratorA
  74.     private function addedBehavior()
  75.     {
  76.         echo "ConcreteDecoratorB Status.\n";
  77.     }
  78. }
  80. // 客户端代码
  81. // 装饰的方法是：首先用ConcreteComponent实例化对象c,
  82. // 然后用ConcreteDecoratorA的实例对象$di来包装$c,
  83. // 然后再用ConcreteDecoratorB的实例$d2包装$d1,
  84. // 最终执行$d2的Operation(); 
  85. $c = new ConcreteComponent();
  86. $d1 = new ConcreteDecoratorA();
  87. $d2 = new ConcreteDecoratorB();
  89. $d1->SetComponent($c);
  90. $d2->SetComponent($d1);
  91. $d2->Operation();

当只有一个ConcreteComponent类而没有抽象的Component类 ，那么Decorator类可以是ConcreteComponent的一个子类。同样的道理，如果只有一个ConcreteDecorator类 ，那么就没有必要建立一个单独的Decorator类，而可以把Decorator类和ConcreteComponent类的责任合并成一个类。

书中用打扮的代码阐释了这样情况下的写法：

  1. <?php 
  3. // 人
  4. class Person
  5. {   
  6.     private $name;
  7.     function __construct($name)
  8.     {
  9.         $this->name = $name;
  10.     }
  12.     public function show()
  13.     {
  14.         echo "打扮".$this->name."\n";
  15.     }
  16. }
  19. // 服饰类
  20. class Finery
  21. {
  22.     protected $person;
  24.     public function decorate($person)
  25.     {
  26.         $this->person = $person;
  27.     }
  29.     public function show()
  30.     {
  31.         if ($this->person != null)
  32.         {
  33.             $this->person->show();
  34.         }
  35.     }
  36. }
  38. // 具体服饰类
  39. class TShirts extends Finery
  40. {
  41.     public function show()
  42.     {
  43.         echo "大T恤\n";
  44.         parent::show();
  45.     }
  46. }
  48. class BigTrouser extends Finery
  49. {
  50.     public function show()
  51.     {
  52.         echo "跨裤\n";
  53.         parent::show();
  54.     }
  55. }
  57. class Sneakers extends Finery
  58. {
  59.     public function show()
  60.     {
  61.         echo "破球鞋\n";
  62.         parent::show();
  63.     }
  64. }
  66. class Suit extends Finery
  67. {
  68.     public function show()
  69.     {
  70.         echo "西装\n";
  71.         parent::show();
  72.     }
  73. }
  75. class Tie extends Finery
  76. {
  77.     public function show()
  78.     {
  79.         echo "领带\n";
  80.         parent::show();
  81.     }
  82. }
  84. class LeatherShoes extends Finery
  85. {
  86.     public function show()
  87.     {
  88.         echo "跨裤\n";
  89.         parent::show();
  90.     }
  91. }
  94. // 客户端代码
  95. $person = new Person("alex");
  97. $sneakers = new Sneakers();
  98. $bigTrouser = new BigTrouser();
  99. $tShirts = new TShirts();
  101. $sneakers->decorate($person);
  102. $bigTrouser->decorate($sneakers);
  103. $tShirts->decorate($bigTrouser);
  104. $tShirts->show();

总结

装饰模式，动态地给一个对象添加一些额外的职责，就增加功能来说，装饰模式比生成子类更为灵活。

装饰模式是为已有功能动态的添加更多功能的一种方式。

当系统需要新功能的时候，是向旧的类中添加新的代码。这些新的代码通常装饰了原有类的核心职责或主要行为。

在主类中加入新的字段，新的方法和新的逻辑，从而增加了主类的复杂度，而这些新加入的东西仅仅是为满足一些只在某种特定情况下才会执行的特殊行为的需要。装饰模式却提供了一个非常好的解决方案，它把每个要装饰的功能放在单独的类中，并让这个类包装它要装饰的对象，对此，当需要执行特殊行为时，客户代码就可以在运行时根据需要选择地，按顺序地使用装饰功能包装对象了。

装饰模式的优点就是把类中的装饰功能从类中搬移去除，这样可以简化原有的类。

有效地把类的核心职责和装饰功能区分开了，而且可以去除相关类中的重复的装饰逻辑。

上一章：第五章 会修电脑不会修收音机？ －－－ 依赖倒转原则

下一章：第七章 为别人做嫁衣 －－－ 代理模式