设计模式（三）：装饰者模式

一、『装饰者模式』定义

动态地将责任附加到对象上。若要扩展功能，装饰者提供了比继承更有弹性的替代方案。

二、场景

下面还是通过具体场景来一步步说明。

场景：在咖啡店点咖啡时，不同人点的咖啡加的调料很可能是不同的，然后用类去描述这些咖啡。

2.1 步骤一

如果要描述每个人点的咖啡（调料不同），都需要一个类去描述。这就导致类的数量非常多，因为调料的组合非常多。

2.2 步骤二

对于上面的问题，可以想到使用实例变量和继承解决。即创建一个饮料超类，所有种类的咖啡（不含调料）都继承自这个饮料超类。再在饮料超类中添加调料（实例变量）以及判断/设置调料的函数，这样就可以使用一个咖啡子类去描述多杯调料不同咖啡。

2.3 步骤三

但是现在又有个问题，如果有新的调料，就需要修改饮料超类的源代码，这样并不利于维护。

设计原则：类应该对扩展开放，对修改关闭。

所以可以使用装饰者模式来设计，即使用调料去装饰咖啡，如下图：

最内层是浓缩咖啡，也就是被装饰类，cost1()只计算初始不含调料的价格；如果需要加上调料Mocha，就用调料Mocha去装饰浓缩咖啡，cost2()计算内层cost1()的价格和自身调料的价格；调料MilkFroth同理，cost3()计算内层cost2()的价格和自身调料的价格。

这样做的好处是，对于新的调料不需要修改饮料超类的源代码，只需要创建一个新的调料类，然后用它装饰指定咖啡就行了。详细看Java代码：

/**
 * 饮料类。是装饰者和被装饰者的超类。
 */
abstract class Beverage{
    String description = "Unkown Beverage";

    public String getDescription() {
        return description;
    }
    public abstract double cost();
}

/**
 * 调料类。是装饰者类的超类。
 */
abstract class CondimentDecorator extends Beverage{
    public abstract String getDescription();
}

/**
 * 饮料：浓缩咖啡。是具体被装饰者。
 */
class Espresso extends Beverage{
    public Espresso() {
        description = "Espresso";
    }

    // 设置饮料的钱，这里不需要管调料的钱
    public double cost() {
        return 1.99;
    }
}

/**
 * 饮料：综合咖啡。是具体被装饰者。
 */
class HouseBlend extends Beverage{
    public HouseBlend() {
        description = "HouseBlend";
    }

    // 设置饮料的钱，这里不需要管调料的钱
    public double cost() {
        return 0.89;
    }
}


/**
 * 调料：摩卡类。是具体装饰者。
 */
class Mocha extends CondimentDecorator{
    Beverage beverage;

    public Mocha(Beverage beverage) {
        this.beverage = beverage;
    }

    public String getDescription() {
        return beverage.getDescription() + ", Mocha";
    }

    public double cost() {
        return 0.20 + beverage.cost();
    }
}

/**
 * 调料：奶泡类。是具体装饰者。
 */
class MilkFroth extends CondimentDecorator{
    Beverage beverage;

    public MilkFroth(Beverage beverage) {
        this.beverage = beverage;
    }

    public String getDescription() {
        return beverage.getDescription() + ", MilkFroth";
    }

    public double cost() {
        return 0.20 + beverage.cost();
    }
}

/**
 * 主类，测试类。
 */
public class StarbuzzCoffee {
    public static void main(String[] args) {
        // 点一杯无调料的“浓缩咖啡”
        Beverage beverage = new Espresso();
        System.out.println(beverage.getDescription() + " $" + beverage.cost());

        // 点一杯加了两份摩卡和一份奶泡的“综合咖啡”
        Beverage beverage2 = new HouseBlend();
        beverage2 = new Mocha(beverage2);
        beverage2 = new Mocha(beverage2);
        beverage2 = new MilkFroth(beverage2);
        System.out.println(beverage2.getDescription() + " $" + beverage.cost());
    }
}

注意：

• 装饰者和被装饰对象有相同的超类型。这是为了可以正常接收装饰者装饰后的类。
• 你可以用一个或多个装饰者包装一个对象。
• 既然装饰者和被装饰对象有相同的超类型，所以在任何需要原始对象（被包装的类）的场合，可以用装饰过的对象代替它。
• 装饰者可以在所委托被装饰者的行为之前或之后，加上自己的行为，以达到特定的目的。
• 对象可以在任何时候被装饰，所以可以在运行时动态地、不限量地用你喜欢的装饰者来装饰对象。

三、总结

1）继承属于扩展形式之一，但不见得是达到弹性设计的最佳方式。
2）在我们的设计中，应该允许行为可以被扩展，而无须修改现有的代码。
3）组合和委托可用于在运行时动态地加上新的行为。
4）除了继承，装饰者模式也可以让我们扩展行为。
5）装饰者模式意味着一群装饰者类，这些类用来包装具体组件。
6）装饰者类反映出被装饰的组件类型（事实上，他们具有相同的类型，都经过接口或继承实现）。
7）装饰者可以在被装饰者的行为前面或后面加上自己的行为，甚至将被装饰者的行为整个取代掉，而达到特定的目的。
8）你可以用无数个装饰者包装一个组件。
9）装饰者一般对组件的客户是透明的，除非客户程序依赖于组件的具体类型。
10）装饰者会导致设计中出现许多小对象，如果过度使用，会让程序变得很复杂。

参考

《HeadFirst设计模式》