问题：星巴克售卖饮品，需要计算饮品的价格。饮品有几种基础饮品：无咖啡因咖啡、超优深焙咖啡、浓咖啡等等，每个基础饮品可以添加调料最后产生最终的饮品。由于星巴克扩张迅速，需要快速退出新品，调料和基础饮品都可以增加和改变，如何设计系统，才能优雅的应对调料和基础饮品的增加。
核心思想：用组合代替继承，来扩张类的功能
设计原则：类应该对扩展开放，对修改关闭
实现：一个最基础的类，这个类会有一个接口 cost，每个基础饮品都需要实现继承这个基础类，实现 cost 接口（基础饮品的价格）。装饰者类继承这个基础类（可以添加一些新的方法比如 printDescription()）, 每个装饰者都应该继承这个装饰者类或者实现这个装饰者类的接口（go 中的 interface）
缺陷：由于每个调料都是一个装饰者（类），在实现过程中，会依赖大量的类，声明大量类的实例，不便于管理，工厂模式和生成器模式会解决这个问题
示例代码：
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
|
class beverage {
string description;
public:
beverage() {}
beverage(string s) : description(s) {}
virtual string describe() {
return description;
}
virtual double cost() = 0;
};
class Espresso : public beverage {
public:
Espresso() : beverage("浓咖啡") {}
double cost() override {
return 2.0;
}
};
class DarkRoast : public beverage {
public:
DarkRoast() : beverage("深焙咖啡") {}
double cost() override {
return 3.0;
}
};
class condimentDecorater : public beverage {
public:
virtual string describe() = 0;
condimentDecorater() {};
};
class milk : public condimentDecorater {
beverage &b;
public:
milk(beverage &b) : b(b) {}
string describe() {
return b.describe() + "+牛奶";
}
double cost() {
return b.cost() + 0.5;
}
};
class mocha : public condimentDecorater {
beverage &b;
public:
mocha(beverage &b) : b(b) {}
string describe() {
return b.describe() + "+摩卡";
}
double cost() {
return b.cost() + 1;
}
};
int main() {
Espresso espresso;
DarkRoast darkRoast;
beverage *milkEspresso = new milk(espresso);
beverage *mochaDarkRoast = new mocha(darkRoast);
cout << milkEspresso->describe() << " cost:" << milkEspresso->cost() << endl;
cout << mochaDarkRoast->describe() << " cost:" << mochaDarkRoast->cost() << endl;
return 0;
}
|
示例非常简单，几乎不涉及什么内存管理，当装饰者模式设计到复杂的对象的时候，可以考虑使用 c++的智能指针来管理内存，毕竟装饰者模式会涉及非常多的对象和相互引用。
Rookiecom