运行时扩展，远比编译时期的继承威力大。我们将讨论如何使用对象组合的方式，做到在运行时装饰类。

利用继承设计子类的行为，是在编译时静态决定的，而且所有子类都会继承相同的行为。然而，如果能够利用组合的做法扩展对象的行为，就可以在运行时动态地进行扩展，而不需修改现有代码。既然没有改变现有代码，那么出现 bug 的可能就不大幅降低。

设计原则

开放-关闭原则

类应该对外扩展开发，对修改关闭。

定义

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

类图

代码实现

我们以咖啡厅为例，来模拟一个装饰者模式的实现。

首先，咖啡厅售卖一种咖啡，这种咖啡原价是 ￥10，如果客户需要加糖的话，就需要加上糖的价格 ￥2，客户还可以选择是否加牛奶，牛奶的价格是 ￥5。加糖或者咖啡都可以看做是对咖啡口味的装饰。

那么，在这个案例当中，咖啡就是被装饰者，糖和牛奶是两个装饰者，通过给咖啡装饰（这里是不同的口味，甜味或者牛奶味，亦或者两者都加），来售卖不同口味的咖啡，当然价格也会不同。

下面我们用代码来实现：

package com.study.design.Decorator;

/**
 * 被装饰者抽象类
 */
public abstract class Coffe {

    /**
     * 计算价格的方法
     * @return
     */
    protected abstract int cost();

}

package com.study.design.Decorator;

/**
 * 被装饰者对象
 * 原味咖啡，售价 ￥10
 */
public class OriginalCoffe extends Coffe{

    @Override
    protected int cost() {
        return 10;
    }
}

package com.study.design.Decorator;

public abstract class Decorator extends Coffe{

    // 被装饰者对象
    protected Coffe coffe;

    protected abstract int additional();

}

package com.study.design.Decorator;

/**
 * 装饰者
 * 加糖 ￥2
 */
public class Sugar extends Decorator{

    public Sugar(Coffe coffe){
        this.coffe = coffe;
    }

    @Override
    protected int cost() {
        return coffe.cost() + additional();
    }

    @Override
    protected int additional() {
        return 2;
    }
}

package com.study.design.Decorator;

/**
 * 装饰者
 * 加牛奶 ￥5
 */
public class Milk extends Decorator{

    public Milk(Coffe coffe){
        this.coffe = coffe;
    }

    @Override
    protected int cost() {
        return coffe.cost() + additional();
    }

    @Override
    protected int additional() {
        return 5;
    }
}

package com.study.design.Decorator;

public class DecoratorTest {

    public static void main(String[] args) {

        OriginalCoffe originalCoffe = new OriginalCoffe();
        System.out.println("原味咖啡价格:" + originalCoffe.cost());
        Sugar sugar = new Sugar(originalCoffe);
        System.out.println("加糖后的价格:" + sugar.cost());
        Milk milk = new Milk(originalCoffe);
        System.out.println("加牛奶后的价格" + milk.cost());
        milk = new Milk(sugar);
        System.out.println("加牛奶加糖后的价格:" + milk.cost());

    }
}

熟悉 AOP 的同学到这里应该会联想到，在装饰者中增加的新方法或者说功能，这不就像是 AOP 中的前置通知、后置通知么？

是的！不过 AOP 底层是通过动态代理实现的，动态代理与装饰者模式本质区别就是，前者关注的是对代理对象行为控制，不同的代理对象实现被代理对象行为的不同的控制，并且这些代理对象很少有组合的可能。

而后者侧重于对被装饰者功能的扩展。不同的装饰者为被装饰者增添不同的功能，并且这些装饰者可以任意嵌套组合。比如糖和牛奶可以同时添加。

Java I/O 中的装饰者模式

对于装饰者模式，最经典的就是 Java I/O 中的应用。了解了装饰者模式，再回头系统地看下有关 Java I/O 的源码就会流畅很多。

以上展示了输入流的部分类图关系，输出流也是一样。但 Java I/O 也引出了装饰者模式的一个“缺点”：利用装饰者模式，常常会造成设计中有大量的小类，数量实在太多，可能会造成使用此 API 的开发人员的困扰。但是，如果了解了装饰者模式的原理，以后当使用别人的大量装饰的 API 时，就可以很容易的辨别出他们的装饰者类时如何组织，以方便用包装方式取得想要的行为。

要点

• 所有被装饰者和装饰者需要继承自统一的父类或者实现同一个接口
• 装饰者须持有一个被装饰者接口类型的对象
• 装饰者可以在被装饰者前/后加上自己的行为，甚至将被装饰者的行为整个取代掉，而达到特定的目的
• 装饰者会导致设计中出现许多小对象，如果过度使用，会让程序变得很复杂