HeadFirst设计模式（三） - 装饰者模式
装饰对象
我们即将讨论典型的继承滥用问题。并学到如何使用对象组合的方式，做到在运行时装饰类。
用一个简单的需求来描述问题，星巴兹(Starbuzz)需要准备订单系统，这是他们的第一个尝试，类设计是这样的：
Beverage（饮料）是一个抽象类，店内所提供的饮料都必须继承自此类，这个类有一个description（描述）的实例变量，可以由每个子类设置，用来描述饮料，例如：超优深培咖啡豆（Dark Roast）等。cost()方法是抽象的，子类必须定义自己的实现。每个子类都实现cost()来返回饮料的价钱。购买咖啡时，也可以要求在其中加入各种调料，例如：蒸奶、豆浆、摩卡或覆盖奶泡。咖啡店会根据加入的调料收取不同的费用。
代码与客户端调用如下：
package cn.net.bysoft.decorator;
// 饮料的基类。
public abstract class Beverage {
// 计算价格的方法。
public abstract double cost();
// 饮料描述的getter and setter。
public String getDescription() {
return description;
}
public void setDescription(String description) {
this.description = description;
}
// 饮料的描述。
private String description = "";
}
package cn.net.bysoft.decorator;
// 深焙咖啡对象。
public class DarkRoast extends Beverage {
@Override
public double cost() {
// 牛奶 + 糖 + 深焙咖啡豆 = 1$
return 1.00D;
}
}
package cn.net.bysoft.decorator;
// 浓缩咖啡对象。
public class Espresso extends Beverage {
@Override
public double cost() {
// 浓缩咖啡价格是1.15$。
return 1.15D;
}
}
package cn.net.bysoft.decorator;
public class Client {
public static void main(String[] args) {
// 来一杯浓缩咖啡。
Beverage espresson = new Espresso();
System.out.println("浓缩咖啡的价格是：" + espresson.cost() + "$");
// 来一杯深焙咖啡。
Beverage darkRoast = new DarkRoast();
System.out.println("深焙咖啡的价格是：" + darkRoast.cost() + "$");
/**
* output:
* 浓缩咖啡的价格是：1.15
* 深焙咖啡的价格是：1.0
* */
}
}
很明显，咖啡店为自己制造了一个维护的噩梦，看类图，假如咖啡店有82种咖啡，如果牛奶的价钱上扬，需要改动所有与牛奶有关的咖啡的价格，如果咖啡豆价格上调的话……如果新增一种所有饮料都试用的焦糖风味，所有类都要改变……
这时候，有些人已经想到了解决办法，利用实例变量与继承，就可以追踪这些调料。
好吧，就来试试看。先从Beverage基类下手，加上实例变量代表是否加上调料，现在，Beverage类中的cost()不再是一个抽象方法，我们提供了cost()的实现，让他计算要加入各种饮料的调料价钱。子类仍覆盖cost()，但是会调用超类的cost()，计算出基本饮料加上调料的价钱。看一下代码如何实现：
package cn.net.bysoft.decorator;
// 饮料的基类。
public abstract class Beverage {
// 基类计算所有调料的价钱。
public double cost() {
double price = 0.0D;
if (hasMilk()) {
price += 0.2D;
}
if (hasSoy()) {
price += 0.2D;
}
if (hasMocha()) {
price += 0.3D;
}
if (hasWhip()) {
price += 0.3D;
}
return price;
}
// 饮料描述的getter and setter。
public String getDescription() {
return description;
}
public boolean hasMilk() {
return milk;
}
public void setMilk(boolean milk) {
this.milk = milk;
}
// getter and setter...
// 饮料的描述。
private String description = "";
private boolean milk = false;
private boolean soy = false;
private boolean mocha = false;
private boolean whip = false;
}
package cn.net.bysoft.decorator;
// 深焙咖啡对象。
public class DarkRoast extends Beverage {
@Override
public double cost() {
// 深焙咖啡使用牛奶。
double price = 0.0D;
super.setMilk(true);
// 计算了牛奶的价钱，在加上深焙咖啡的原料。
// 0.2 + 1.05 = 1.25;
price = super.cost() + 1.05;
return price;
}
}
package cn.net.bysoft.decorator;
public class Client {
public static void main(String[] args) {
// 来一杯深焙咖啡。
Beverage darkRoast = new DarkRoast();
System.out.println("深焙咖啡的价格是：" + darkRoast.cost() + "$");
/**
* output:
* 深焙咖啡的价格是：1.25$
* */
}
}
这种做法，非常容易的就解决的前一种设计的问题，咖啡店很满意，开始使用修改后的订单系统。
过了一阵子，发现这种设计并不能满足日常应用，比如：
调料价格的改变还是要修改现有代码；
一旦出现新的调料，就需要加上新的hasXXX方法，并改变超类中的cost()方法；
以后可能会开发出新饮料，对于这些饮料（例如冰茶等），某些调料可能并不合适，但是在这个设计方式汇总，Tea（茶）子类仍然继承哪些不合适的方法，比如hasWhip（加奶泡）；
万一顾客想要双倍的摩卡或者双倍的糖怎么办；
此刻，就面临了最重要的设计原则之一：
设计原则
类应该对扩展开放，对修改关闭。
我们的目标是允许类容易扩展，在不修改现有代码的情况下，就可以配置新的行为。如能实现这样的目标，有什么好处呢？这样的设计具有弹性可以应对改变，可以接受新的功能来应对需求变更。
认识装饰者模式
好了，我们已经了解到利用继承无法完全解决问题，在咖啡馆遇到的问题有：类数量爆炸、设计死板，以及基类加入的新功能并不适用于所有的子类。
所以，在这里要采用不一样的做法：我们要以饮料为主题，然后在运行时以调料来“装饰”(decorate)饮料。比方说，如果顾客想要摩卡和奶泡的深培咖啡，那么，要做的是：
拿一个深培咖啡（DarkRoast）对象；
以摩卡（Mocha）对象装饰它；
以奶泡（WHip）对象装饰它；
调用cost()方法，并依赖委托(delegate)将调料的价钱加上去；
这样就完工了一个深培咖啡对象，但是如何“装饰”一个对象，而“依赖委托”又要如何与此搭配使用呢？
装饰者（调料）和被装饰者（饮料）都有相同的超类；
可以用一个或多个装饰者（调料）包装一个被装饰者（饮料）；
既然装饰者和被装饰者都有相同的超类，那么在任何需要原始对象，也就是被装饰者（饮料）的场合，都可以使用装饰过的对象（饮料）代替它；
装饰者可以在所委托的被装饰者的行为之前或之后，加上自己的行为，以达到特定的目的；
对象可以在任何时候被装饰，所以可以在运行时动态地、不限量地用你喜欢的装饰者来装饰对象；
现在，就来卡看装饰者模式的定义，并写一些代码，了解它到底是怎么工作的吧！先来看看装饰者模式的类图：
Component（组件）类：每个组件都可以单独使用，或者被装饰者包装起来使用。
ConcreteComponent（被装饰组件）类：我们将要动态地加上新行为的对象，它拓展自Component类。
Decorator（装饰）类：每一个装饰者都“有一个”（包装一个）组件，也就是说，装饰者有一个实例变量以保存某个Component的引用。
ConcreteDecoratorXX类：有一个实例变量可以记录所装饰的事物，还可以加上新的方法。
现在，让咖啡店的订单系统也符合此框架：
左侧4个类HouseBlend、DarkRoast、Decaf、Espresso是具体的组件类，而右下角的4个类Milk、Mocha、Soy、Whip是具体的装饰者类，这么一看并没有感觉到装饰者有多厉害，让我们用代码来实现以后在看看效果，现在的需求为：“来一杯双倍摩卡豆浆奶泡拿铁咖啡”，使用订单系统得到正确的价钱：
package cn.net.bysoft.decorator;
// 饮料的基类。
public abstract class Beverage {
// 饮料的说明。
String description = "Unknow Beverage";
public String getDescription() {
return description;
}
public abstract double cost();
}
第一个与我们见面的类是饮料的基类，有两个方法，分别是getDescription()和cost()，用来返回饮料说明和价格。
package cn.net.bysoft.decorator;
// 调料对象。
public abstract class CondimentDecorator extends Beverage {
// 饮料描述。
public abstract String getDescription();
}
第二个出现的类是调料的抽象类，首先，必须让该类能取代Beverage，所以继承自Beverage类。
它的方法getDescription()必须让所有的调料类都实现。
现在，基类已经有了，开始实现一些饮料吧！先从浓缩咖啡开始。
package cn.net.bysoft.decorator;
// 浓缩咖啡对象。
public class Espresso extends Beverage {
public Espresso() {
super.description = "Espresso Coffee";
}
@Override
public double cost() {
return 1.99D;
}
}
首先，让Espresso拓展自Beverage类，因为浓缩咖啡也是一种饮料。然后设置浓缩咖啡的说明属性description，最后使用cost()方法返回价格。
再实现一个黑咖啡（HouseBlend）和深焙咖啡（DarkRoast），代码同上，其余的饮料都一样。
package cn.net.bysoft.decorator;
// 黑咖啡对象。
public class HouseBlend extends Beverage {
public HouseBlend() {
super.description = "House Blend Coffee";
}
@Override
public double cost() {
return .89;
}
}
package cn.net.bysoft.decorator;
// 深焙咖啡对象。
public class DarkRoast extends Beverage {
public DarkRoast() {
super.description = "DarkRoast Coffee";
}
@Override
public double cost() {
return .89;
}
}
写好具体的饮料对象后，就可以着手调料类的编写了：
package cn.net.bysoft.decorator;
public class Mocha extends CondimentDecorator {
// 需要装饰的类。
Beverage beverage;
public Mocha(Beverage beverage) {
this.beverage = beverage;
}
@Override
public String getDescription() {
return beverage.getDescription() + ", Mocha";
}
@Override
public double cost() {
return .20 + beverage.cost();
}
}
摩卡(Mocha)是一个装饰者，拓展自CondimentDecorator类，也就是说，摩卡也是一个Beverage类。
摩卡对象中有一个Beverage对象用于存放要封装的具体饮料类，目前有Espresso和HouseBlend两个饮料。
在构造函数中把具体饮料当作参数传递到Mocha中。
在描述时，不只是调用传递进来的饮料的描述，还可以加入自己想要加入的描述（例如“DarkRoast, Mocha”）。
最后cost()方法，首先调用传递进来的饮料的cost()方法，获得价格，在加上Mocha自己的钱，得到最终结果。
在最后测试之前，实现奶泡条件，完成需求：
package cn.net.bysoft.decorator;
// 奶泡调料
public class Whip extends CondimentDecorator {
// 需要装饰的类。
Beverage beverage;
public Whip(Beverage beverage) {
this.beverage = beverage;
}
@Override
public String getDescription() {
return beverage.getDescription() + ", Whip";
}
@Override
public double cost() {
return .20 + beverage.cost();
}
}
下面就是使用订单的一些测试代码：
package cn.net.bysoft.decorator;
public class Client {
public static void main(String[] args) {
// 订一杯浓缩咖啡，不需要调料，打印价格。
Beverage beverage = new Espresso();
System.out.println(beverage.getDescription() + " $" + beverage.cost());
System.out.println();
// 订一杯深焙咖啡，加入双倍的Mocha，在加入奶泡。
// 因为调料与饮料都是扩展自Beverage，所以可以使用下面的等式。
Beverage beverage2 = new DarkRoast();
beverage2 = new Mocha(beverage2);
beverage2 = new Mocha(beverage2);
beverage2 = new Whip(beverage2);
System.out
.println(beverage2.getDescription() + " $" + beverage2.cost());
System.out.println();
/**
* output:
* Espresso Coffee $1.99
*
* DarkRoast Coffee, Mocha, Mocha, Whip $1.49
* */
}
}
再来拓展一下需求，现在咖啡店决定开始在菜单上为所有饮料加入容量，提供小杯(Tall)、中杯(Grande)、大杯(Venti)饮料，每次加入摩卡和奶泡不是按照固定的0.20美金收费了，而是按照，小中大杯的咖啡加摩卡和奶泡时，判断size，然后分别加收0.1、0.15、0.2美金。
如何改变装饰者类对应这样的需求呢？
首先，在饮料基类中加入SIZE属性：
public enum BeverageSize {
TALL, GRANDE, VENTI
}
public abstract class Beverage {
BeverageSize size = BeverageSize.TALL;
public void setSize(BeverageSize size) {
this.size = size;
}
public String getDescription() {
return description;
}
...
}
然后，修改摩卡和奶泡的cost方法，修改之前将摩卡和奶泡类中的Beverage提取到基类CondimentDecorator中：
// 调料对象。
public abstract class CondimentDecorator extends Beverage {
Beverage beverage;
public BeverageSize getSize() {
return beverage.getSize();
}
...
}
package cn.net.bysoft.decorator;
public class Mocha extends CondimentDecorator {
public Mocha(Beverage beverage) {
super.beverage = beverage;
}
@Override
public double cost() {
double cost = beverage.cost();
if (getSize() == BeverageSize.TALL) {
cost += .10;
} else if (getSize() == BeverageSize.GRANDE) {
cost += .15;
} else if (getSize() == BeverageSize.VENTI) {
cost += .20;
}
return cost;
}
...
}
奶泡的类，与摩卡类相同，最后进行测试：
public static void main(String[] args) {
// 订一杯深焙咖啡，加入双倍的Mocha，在加入奶泡。
Beverage beverage2 = new DarkRoast();
// 大杯饮料，每种调料0.15美金。
beverage2.setSize(BeverageSize.GRANDE);
beverage2 = new Mocha(beverage2);
beverage2 = new Mocha(beverage2);
beverage2 = new Whip(beverage2);
// 0.89+0.15+0.15+0.15 = 1.34
System.out.println(beverage2.getDescription() + " $"
+ String.format("%.2f", beverage2.cost()));
System.out.println();
/**
* output: DarkRoast Coffee, Mocha, Mocha, Whip $1.34
* */
}
以上就是装饰者模式的全部内容。
另外，java.io包内的类大量的使用了装饰者模式，比如：
FileInputStrame被BufferedInputStream装饰。
而BufferedInputStream又被LineNumberInputStream装饰。
具体的细节可以查看java的api和源码。