设计模式之装饰者模式
**装饰者模式： **动态地将责任附加到对象上。若要扩展功能，装饰者提供了比继承更有弹性的替代方案。
原则： 对扩展开放，对修改关闭。
问题引入：
购买咖啡时，也可以要求在其中加入各种调料，例如：蒸奶（Steamed Milk）、豆浆（Soy）、摩卡（Mocha，也就是巧克力风味）或覆盖奶泡。星巴兹会根据所加入的调料收取不同的费用。所以订单系统必须考虑到这些调料部分。
带来的问题： 类数量爆炸、设计死板，以及基类加入的新功能并不适用于所有的子类。
解决方法：
以饮料为主体，然后在运行时以调料来“装饰”（decorate）饮料。
比方说，如果顾客想要摩卡和奶泡深焙咖啡，那么，要做的是：
1 拿一个深焙咖啡（DarkRoast）对象
2 以摩卡（Mocha）对象装饰它
3 以奶泡（Whip）对象装饰它
4 调用cost()方法，并依赖委托（delegate）将调料的价钱加上去。
目前已知归纳：
- 装饰者和被装饰对象有相同的超类型。
- 你可以用一个或多个装饰者包装一个对象。
- 既然装饰者和被装饰对象有相同的超类型，所以在任何需要原始对象（被包装的）的场合，可以用装饰过的对象代替它。
- 装饰者可以在所委托被装饰者的行为之前与/或之后，加上自己的行为，以达到特定的目的。
- 对象可以在任何时候被装饰，所以可以在运行时动态地、不限量地用你喜欢的装饰者来装饰对象。
装饰者模式 类图
饮料类图
大师： 我说蚱蜢呀！距离我们上次见面已经有些时日，你对于继承的冥想，可有精进？
门 徒：是的，大师。尽管继承威力强大，但是我体会到它并不总是能够实现最有弹性和最好维护的设计。
大师：啊！是的，看来你已经有所长进。那么，告诉我，我的门徒，不通过继承又能如何达到复用呢？
门徒：大师，我已经了解到利用组合（composition）和委托（delegation）可以在运行时具有继承行为的效果。
大师：好，好，继续……
门徒：利用继承设计子类的行为，是在编译时静态决定的，而且所有的子类都会继承到相同的行为。然而，如果能够利用组合的做法扩展对象的行为，就可以在运行时动态地进行扩展。
大师：很好，蚱蜢，你已经开始看到组合的威力了。
门徒：是的，我可以利用此技巧把多个新职责，甚至是设计超类时还没有想到的职责加在对象上。而且，可以不用修改原来的代码。
大师：利用组合维护代码，你认为效果如何？
门徒：这正是我要说的。通过动态地组合对象，可以写新的代码添加新功能，而无须修改现有代码。既然没有改变现有代码，那么引进bug或产生意外副作用的机会将大幅度减少。
大师：非常好。蚱蜢，今天的谈话就到这里。希望你能在这个主题上更深入……牢记，代码应该如同晚霞中的莲花一样地关闭（免于改变），如同晨曦中的莲花一样地开放（能够扩展 )
Sue：这话怎么说？
Mary：看看类图。CondimentDecorator扩展自Beverage类，这用到了继承，不是吗？
Sue：的确是如此，但我认为，这么做的重点在于，装饰者和被装饰者必须是一样的类型，也就是有共同的超类，这是相当关键的地方。在这里，我们利用继承达到“类型匹配”，而不是利用继承获得“行为”。
Mary：我知道为何装饰者需要和被装饰者（亦即被包装的组件）有相同的“接口”，因为装饰者必须能取代被装饰者。但是行为又是从哪里来的？
Sue：当我们将装饰者与组件组合时，就是在加入新的行为。所得到的新行为，并不是继承自超类，而是由组合对象得来的。
Mary：好的。继承Beverage抽象类，是为了有正确的类型，而不是继承它的行为。行为来自装饰者和基础组件，或与其他装饰者之间的组合关系。
Sue：正是如此。
Mary：哦！我明白了。而且因为使用对象组合，可以把所有饮料和调料更有弹性地加以混和与匹配，非常方便。
Sue：是的。如果依赖继承，那么类的行为只能在编译时静态决定。换句话说，行如果不是来自超类，就是子类覆盖后的版本。反之，利用组合，可以把装饰者混合着用……而且是在“运行时”。
Mary：而且，如我所理解的，我们可以在任何时候，实现新的装饰者增加新的行为。如果依赖继承，每当需要新行为时，还得修改现有的代码。
Sue：的确如此。
Mary：我还剩下一个问题，如果我们需要继承的是component类型，为什么不Beverage 类设计成一个接口，而是设计成一个抽象类呢？
Sue：关于这个嘛，还记得吗？当初我们从星巴兹拿到这个程序时，Beverage“经”是一个抽象类了。通常装饰者模式是采用抽象类，但是在Java中可以使用接口。尽管如此，通常我们都努力避免修改现有的代码，所以，如果抽象类运作得好好的，还是别去修改它。
代码实现
Beverage类
public abstract class Beverage {
String description = "Unknown Beverage";
static final int TALL = 0;
static final int GRANDE = 1;
static final int VENTI = 2;
int size = 1;
// 咖啡容量: 大、中、小
public int getSize() {
return size;
}
public void setSize(int size) {
this.size = size;
}
public String getDescription() {
return description;
}
public abstract double cost();
}
Condiment（调料）抽象类
public abstract class CondimentDecorator extends Beverage{
@Override
public abstract String getDescription();
}
饮料 (浓缩咖啡Espresso )
public class Espresso extends Beverage {
public Espresso() {
description = "Espresso";
}
public double cost() {
return 1.99;
}
}
调料代码
// 摩卡是一个装饰者，所以让它扩展自CondimentDecorator。
// 让Mocha(装饰者)能够引用一个Beverage(被装饰者)
public class Mocha extends CondimentDecorator{
Beverage beverage; // 用一个实例变量记录饮料，也就是被装饰者。
// 让被装饰者（饮料）被记录到实例变量中。
public Mocha(Beverage beverage) {
this.beverage = beverage;
}
@Override
public double cost() {
return .20 + beverage.cost();
}
@Override
public String getDescription() {
return beverage.getDescription() + ", Mocha";
}
}
// 调料根据咖啡容量收费 小中大杯的咖啡加上豆浆Soy，分别加收0.10、0.15、0.20美金
public class Soy extends CondimentDecorator{
Beverage beverage;
public Soy(Beverage beverage) {
this.beverage = beverage;
}
// 现在要把getSize()传播到被包装的饮料。因为所有的调料装饰者都会用到这个方法，
// 所以也应该把它移到抽象类中。
@Override
public int getSize() {
return beverage.getSize();
}
@Override
public double cost() {
double cost = beverage.cost();
if (getSize() == Beverage.TALL) {
cost += .10;
} else if (getSize() == Beverage.GRANDE) {
cost += .15;
} else if (getSize() == Beverage.VENTI) {
cost += .20;
}
return cost;
}
@Override
public String getDescription() {
return beverage.getDescription() + ", Soy";
}
}
下订单的测试代码
public class StarbuzzCoffee {
public static void main(String[] args) {
// 订一杯Espresso，不需要调料，打印出它的描述与价钱
Beverage beverage = new Espresso();
System.out.println(beverage.getDescription()
+ " $" + beverage.cost());
// 制造出一个DarkRoast对象。用Mocha、Mocha、Whip装饰它
Beverage beverage2 = new DarkRoast();
beverage2 = new Mocha(beverage2);
beverage2 = new Mocha(beverage2);
beverage2 = new Whip(beverage2);
System.out.println(beverage2.getDescription()
+ " $" + beverage2.cost());
Beverage beverage3 = new HouseBlend();
beverage3.setSize(Beverage.TALL); // 调整杯的大小
beverage3 = new Soy(beverage3);
beverage3 = new Mocha(beverage3);
beverage3 = new Whip(beverage3);
System.out.println(beverage3.getDescription()
+ " $" + beverage3.cost());
}
}
真实世界的装饰者：Java I/O
BufferedInputStream及LineNumberInputStream都扩展自FilterInputStream，而FilterInputStream是一个抽象的装饰类。
编写自己的Java I/0装饰者
当读取“I know the Decorator Pattern therefore I RULE!”，
装饰者会将它转成“i know the decorator pattern therefore i rule!”
实现方式 ：扩展FilterInputStream类，并覆盖read()方法
public class LowerCaseInputStream extends FilterInputStream {
public LowerCaseInputStream(InputStream in) {
super(in);
}
// 实现两个read()方法, 一个针对字节，一个针对字节数组
@Override
public int read() throws IOException {
int c = super.read();
return (c == -1 ? c : Character.toLowerCase((char) c));
}
@Override
public int read(byte[] b, int offset, int len) throws IOException {
int result = super.read(b, offset, len);
for (int i = offset; i < offset + result; i++) {
b[i] = (byte) Character.toLowerCase((char) b[i]);
}
return result;
}
}
// 测试类
public class InputTest {
public static void main(String[] args) throws IOException{
int c;
try {
InputStream in =
new LowerCaseInputStream(
new BufferedInputStream(
new FileInputStream("C:\\桌面\\test.txt")));
while ((c = in.read()) >= 0) {
System.out.print((char) c);
}
} catch (IOException e) {
e.printStackTrace();
}
}
}
要点
� 继承属于扩展形式之一，但不见得是达到弹性设计的最佳方式。
� 在我们的设计中，应该允许行为可以被扩展，而无须修改现有的代码。
� 组合和委托可用于在运行时动态地加上新的行为。
� 除了继承，装饰者模式也可以让我们扩展行为。
� 装饰者模式意味着一群装饰者类 ， 这 些 类 用 来 包 装 具 体 组件。
� 装饰者类反映出被装饰的组件类型（事实上，他们具有相同的类型，都经过接口或继承实现）。
� 装饰者可以在被装饰者的行为前面与/或后面加上自己的行为 ， 甚 至 将 被 装 饰 者 的 行 为整个取代掉，而达到特定的目的。
� 你可以用无数个装饰者包装一个组件。
� 装饰者一般对组件的客户是透明的，除非客户程序依赖于组件的具体类型。
� 装饰者会导致设计中出现许多小对象，如果过度使用，会让程序变得很复杂。
浙公网安备 33010602011771号