装饰对象
我们即将讨论典型的继承滥用问题。并学到如何使用对象组合的方式，做到在运行时装饰类。
用一个简单的需求来描述问题，星巴兹(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和源码。