想象一下有如下的场景：
有两种主咖啡， 可以搭配任意的饮料，我们的目标是允许类容易扩展，在不修改现有代码的情况下，可以搭配新的行为。这里可以用装饰者模式来实现。
1. uml 图
装饰者模式动态地将责任附加到对象上，若要扩展功能，装饰者提供了比继承更有弹性的替代方案。
这里吹一下装饰者模式的好处：
- 每个组件都可以单独使用，或者被装饰者包装起来使用
- 装饰者可以扩展组件的状态
- 装饰可以加上新的方法
- 可以为组件添加新的方法而用修改装饰者，反之亦可
2. 代码示例
首先构造基类
1 class Beverage
2 {
3 public :
4 virtual int cost() = 0 ;
5 };
然后 定义组件， 这里定义了两个 Blend 和 DarkRoast
1 class Blend : public Beverage
2 {
3 public :
4 int cost()
5 {
6 return 1 ;
7 }
8 };
1 class DarkRoast : public Beverage
2 {
3 public :
4 int cost()
5 {
6 return 2 ;
7 }
8 };
下一步就定义 装饰者， 这里定义了3个， 所有的装饰者都是从Decorator 类继承的
1 class Decorator : public Beverage
2 {
3 public :
4 int cost()
5 {
6 return observed_ -> cost() + 0 ;
7 }
8 void setObserver(shared_ptr < Beverage > observed)
9 {
10 observed_ = observed;
11 }
12
13 protected :
14 shared_ptr < Beverage > getObserver()
15 {
16 return observed_;
17 }
18
19 private :
20 shared_ptr < Beverage > observed_;
21 };
22
23 class Milk : public Decorator
24 {
25 public :
26 int cost()
27 {
28 return getObserver() -> cost() + 1 ;
29 }
30 };
31
32 class Mocha : public Decorator
33 {
34 public :
35 int cost()
36 {
37 return getObserver() -> cost() + 2 ;
38 }
39 };
40 class Soy : public Decorator
41 {
42 public :
43 int cost()
44 {
45 return getObserver() -> cost() + 3 ;
46 }
47 };
最后看下测试代码
1 int _tmain( int argc, _TCHAR * argv[])
2 {
3
4 shared_ptr < Beverage > blendObserved( new Blend()) ;
5 shared_ptr < Beverage > darkObserved( new DarkRoast());
6
7 shared_ptr < Decorator > blendWithMilk( new Milk());
8 blendWithMilk -> setObserver(blendObserved);
9
10 shared_ptr < Decorator > blendWithMocha( new Mocha());
11 blendWithMocha -> setObserver(blendObserved);
12
13 shared_ptr < Decorator > blendWithSoy( new Soy());
14 blendWithSoy -> setObserver(blendObserved);
15
16 cout << blendWithMilk -> cost() << endl;
17 cout << blendWithMocha -> cost() << endl;
18 cout << blendWithSoy -> cost() << endl;
19 return 0 ;
20 }
3. 总结
开放关闭原则： 对扩展开放，对修改关闭。
- 继承属于扩展形式之一，但不见得是达到弹性设计的最佳方式
- 在我们的设计中，应该允许行为可以被扩展，而无需修改实现
- 除了继承，装饰者模式也可以让我们扩展行为，而装饰者模式意味着一群装饰者类来包装具体的组件。
- 装饰者会导致设计中出现许多小对象，如果过度使用会是程序变得复杂。
