意图/目的/定义（intent）

（简短的描述该模式的作用。）
装饰者模式动态的将责任附加到对象上。若要扩展功能，装饰者提供了比继承更有弹性的替代方案。

动机（motivation）

（动机给出来问题以及如何解决这个问题的具体场景。）
星巴兹咖啡的订单实现。

适用性（applicability）

（适用性描述模式可以被应用在什么场合。）

结构（structure）

（结构提供了图示，显示出参与此模式的类之间的关系。）
image.png

参与者（participants）

（参与者描述在此设计中所涉及到的类和对象在模式中的责任和角色。）

协作（collaborations）

（协作告诉我们参与者如何在此模式中合作。）

实现/范例代码（implementation/sample code）

（实现提供了你在实现该模式时需要使用的技巧，以及你应该小心面对的问题。）
（范例代码提供代码的片段，可能对你的实现有多帮助。）

  1. /// 饮料抽象类
  2. abstract class Beverage {
  3.   String description = "Unknown Beverage";
  5.   String getDescription() {
  6.     return description;
  7.   }
  9.   double cost();
  10. }
  12. /// 调料抽象类，继承饮料类
  13. abstract class CondimentDecorator extends Beverage {
  14.   // 调料类装饰者重新实现getDescription()方法
  15.   String getDescription();
  16. }
  18. /// --------------- 饮料代码
  19. // 浓缩咖啡是一种饮料，继承Beverage类
  20. class Espresso extends Beverage {
  21.   Espresso() {
  22.     description = 'Espresso';
  23.   }
  25.   @override
  26.   double cost() {
  27.     return 1.99;
  28.   }
  29. }
  31. /// 综合咖啡，继承自Beverage类
  32. class HouseBlend extends Beverage {
  33.   HouseBlend() {
  34.     description = 'House Blend Coffee';
  35.   }
  37.   @override
  38.   double cost() {
  39.     return 0.89;
  40.   }
  41. }
  43. // 深培咖啡
  44. class DarkRoast extends Beverage {
  45.   DarkRoast() {
  46.     description = 'Dark Roast Coffee';
  47.   }
  49.   @override
  50.   double cost() {
  51.     return 0.99;
  52.   }
  53. }
  55. /// ------------------ 调料代码
  56. // 摩卡是一个装饰者调料，所以它扩展自CondimentDecorator。
  57. class Mocha extends CondimentDecorator {
  58.   // 用一个实例变量记录饮料，也就是被装饰者。
  59.   // 想办法让被装饰着被记录到实例变量中。
  60.   // 这里的做法是：把饮料当做构造器函数的参数，有构造函数将饮料记录在实例变量中。
  61.   Beverage _beverage;
  63.   Mocha(Beverage beverage) {
  64.     this._beverage = beverage;
  65.   }
  67.   // 我们希望叙述不只是描述饮料，而是完整的连调料都描述出来。
  68.   // 首先利用委托的做法，得到一个叙述，然后在其后加上附加的叙述。
  69.   @override
  70.   String getDescription() {
  71.     return '${_beverage.getDescription()}, Mocha';
  72.   }
  74.   @override
  75.   double cost() {
  76.     // 要计算mocha饮料的价钱。
  77.     // 首先把调用委托给被装饰者对象，以计算价钱，然后再加上mocha的价钱，得到最后结果
  78.     return 0.20 + _beverage.cost();
  79.   }
  80. }
  82. // 豆浆
  83. class Soy extends CondimentDecorator {
  84.   Beverage _beverage;
  86.   Soy(Beverage beverage) {
  87.     _beverage = beverage;
  88.   }
  90.   @override
  91.   String getDescription() {
  92.     return '${_beverage.getDescription()}, Soy';
  93.   }
  95.   @override
  96.   double cost() {
  97.     return 0.15 + _beverage.cost();
  98.   }
  99. }
  101. // 奶泡
  102. class Whip extends CondimentDecorator {
  103.   Beverage _beverage;
  105.   Whip(Beverage beverage) {
  106.     _beverage = beverage;
  107.   }
  109.   @override
  110.   String getDescription() {
  111.     return '${_beverage.getDescription()}, Whip';
  112.   }
  114.   @override
  115.   double cost() {
  116.     return 0.10 + _beverage.cost();
  117.   }
  118. }
  120. // 牛奶
  121. class Milk extends CondimentDecorator {
  122.   Beverage _beverage;
  124.   Milk(Beverage beverage) {
  125.     _beverage = beverage;
  126.   }
  128.   @override
  129.   String getDescription() {
  130.     return '${_beverage.getDescription()}, Milk';
  131.   }
  133.   @override
  134.   double cost() {
  135.     return 0.10 + _beverage.cost();
  136.   }
  137. }
  139. /// 测试函数
  140. main(List<String> args) {
  141.   Beverage beverage = new Espresso();
  142.   print('${beverage.getDescription()} \$ ${beverage.cost()}');
  144.   Beverage beverage2 = new DarkRoast();
  145.   beverage2 = new Mocha(beverage2);
  146.   beverage2 = new Milk(beverage2);
  147.   beverage2 = new Whip(beverage2);
  148.   print('${beverage2.getDescription()} \$ ${beverage2.cost()}');
  150.   Beverage beverage3 = new HouseBlend();
  151.   beverage3 = new Mocha(beverage3);
  152.   beverage3 = new Mocha(beverage3);
  153.   beverage3 = new Soy(beverage3);
  154.   print('${beverage3.getDescription()} \$ ${beverage3.cost()}');
  155. }

已知应用（known uses）

（已知应用用来描述已经在真实系统中发现的模式例子。）

相关模式（related patterns）

（相关模式描述了此模式和其他模式之间的关系。）

OO知识

OO基础

  1. 抽象
  2. 封装
  3. 多态
  4. 继承

OO原则

  1. 封装变化
  2. 多用组合少用继承
  3. 针对接口编程，不针对实现编程
  4. 为交互对象之间的松耦合设计而努力

  5. 对扩展开放，对修改关闭

    要点

  6. 继承属于扩展形式之一，但不见得是达到弹性设计的最佳方案。

  7. 在我们的设计中，应该允许行为可以被扩展，而无需修改现有的代码。
  8. 组合和委托可用于在运行时动态的加上新的行为。
  9. 除了继承，装饰者模式也可以让我们扩展行为。
  10. 装饰者模式意味着一群装饰者类，这些类用来包装具体组件。
  11. 装饰者类反映出被装饰的组件类型（事实上，他们具有相同的类型，都经过接口或继承实现）。
  12. 装饰者可以在被装饰者的行为前面与/或后面加上自己的行为，甚至将被装饰者的行为整个取代掉，而达到特定的目的。
  13. 你可以用无数个装饰者包装一个组件。
  14. 装饰者一般对组件的客户是透明的，除非客户程序依赖于组件的具体类型。
  15. 装饰者会导致设计中出现许多小对象，如果过度使用，会让程序变得很复杂。