装饰器模式又叫包装模式，数据结构型模式；是指在不改变现有对象结构的情况下，动态的给改对象增加一些职责（即增加其额外功能）的模式。

在星巴克咖啡店，有美式咖啡（LongBlack）、无因咖啡（Decaf）、意大利农咖啡（Espresso）等不同的咖啡种类，也可以添加牛奶（Milk）、豆浆（Soy）、巧克力(Chocolate)等调料。下面我们就以这个为例子讲解装饰器模式。

使用传统的方式

使用传统的方式设计，就是每一种咖啡和每一种调料都写一个类，都继承自Drink抽象类。这样的缺点是每增加一个单品咖啡，或者增加一个新的调料，类的数量就会成倍增加，形成类爆炸。

装饰器模式

装饰器模式的UML类图:

从上图可以看到装饰器模式主要有抽象构件角色、具体构件角色、抽象装饰角色、具体装饰角色等四个角色：

• 抽象构件角色：给出一个抽象接口，以规范准备接收附加责任的对象
• 具体构件角色：实现抽象构件，并通过装饰角色为其添加一些职责
• 抽象装饰角色：继承抽象构件角色，并包含具体构件的实例，可以通过其子类扩展具体构件的功能
• 具体装饰角色：实现抽象装饰的相关方法，并给具体构件对象添加附加的责任

使用装饰器模式完成上面例子的UML类图：

抽象构件角色：

package com.charon.decorator;

/**
 * @className: Drink
 * @description:
 * @author: charon
 * @create: 2022-03-19 22:48
 */
public abstract class Drink {

    /**
     * 描述
     */
    public String desc;

    /**
     * 价格
     */
    private float price = 0.0f;

    /**
     * Gets the value of desc
     *
     * @return the value of desc
     */
    public String getDesc() {
        return desc;
    }

    /**
     * Sets the desc
     *
     * @param desc desc
     */
    public void setDesc(String desc) {
        this.desc = desc;
    }

    /**
     * Gets the value of price
     *
     * @return the value of price
     */
    public float getPrice() {
        return price;
    }

    /**
     * Sets the price
     *
     * @param price price
     */
    public void setPrice(float price) {
        this.price = price;
    }

    /**
     * 计算费用的方法，交给子类实现
     * @return
     */
    public abstract float cost();
}

具体构建角色：

package com.charon.decorator;

/**
 * @className: Coffee
 * @description:
 * @author: charon
 * @create: 2022-03-19 22:37
 */
public class Coffee extends Drink{

    @Override
    public float cost() {
        return super.getPrice();
    }
}

package com.charon.decorator;

/**
 * @className: LongBlack
 * @description:
 * @author: charon
 * @create: 2022-03-19 23:16
 */
public class LongBlack extends Coffee{
    public LongBlack() {
        setDesc(" 美式咖啡 ");
        setPrice(5.0f);
    }
}

package com.charon.decorator;

/**
 * @className: Decaf
 * @description:
 * @author: charon
 * @create: 2022-03-19 23:11
 */
public class Decaf extends Coffee{
    public Decaf() {
        setDesc(" 无因咖啡  ");
        setPrice(1.0f);
    }
}

抽象装饰角色:

package com.charon.decorator;

/**
 * @className: Decorator
 * @description:
 * @author: charon
 * @create: 2022-03-19 23:13
 */
public class Decorator extends Drink{

    /**
     * 使用聚合的方式
     */
    private Drink drink;

    public Decorator(Drink drink) {
        this.drink = drink;
    }

    @Override
    public float cost() {
        return super.getPrice() + drink.cost();
    }

    @Override
    public String getDesc() {
        return super.getDesc() + "&&" + drink.getDesc();
    }
}

具体装饰角色：

package com.charon.decorator;

/**
 * @className: Milk
 * @description:
 * @author: charon
 * @create: 2022-03-19 23:17
 */
public class Milk extends Decorator{
    public Milk(Drink drink) {
        super(drink);
        setDesc(" 牛奶 ");
        setPrice(2.0f);
    }
}

package com.charon.decorator;

/**
 * @className: Soy
 * @description:
 * @author: charon
 * @create: 2022-03-19 23:18
 */
public class Soy extends Decorator{
    public Soy(Drink drink) {
        super(drink);
        setDesc(" 豆浆 ");
        setPrice(1.5f);
    }
}

测试：

package com.charon.decorator;

/**
 * @className: Client
 * @description:
 * @author: charon
 * @create: 2022-03-19 23:19
 */
public class Client {
    public static void main(String[] args) {
        // 点一份美式咖啡
        Drink longBlack = new LongBlack();
        System.out.println(longBlack.getDesc() + " 费用: " + longBlack.cost());

        // 添加一点牛奶
        longBlack = new Milk(longBlack);
        System.out.println(" 添加了：" + longBlack.getDesc() + " 费用：" + longBlack.cost());

        // 再添加一点豆浆
        longBlack = new Soy(longBlack);
        System.out.println(" 添加了：" + longBlack.getDesc() + " 费用：" + longBlack.cost());
    }
}

打印：
     美式咖啡  费用: 5.0
     添加了： 牛奶 && 美式咖啡  费用：7.0
     添加了： 豆浆 && 牛奶 && 美式咖啡  费用：8.5

装饰器模式以对客户端透明的方式扩展对象的功能，是继承关系的一个替代方案。

装饰器模式的优点：

1. 装饰器模式是对继承的有利补充，比继承灵活，在不改变原有对象的情况下，动态的给一个对象扩展功能，即插即用
2. 通过使用不同装饰类及这些装饰类的排列组合，可以实现不同的效果
3. 装饰器模式完全遵循“开闭原则”

装饰器模式的缺点：

• 装饰器模式会增加许多子类，过度使用会增加程序的复杂性

装饰器模式的应用场景

下面介绍其适用的应用场景，装饰器模式通常在以下几种情况使用。

• 当需要给一个现有类添加附加职责，而又不能采用生成子类的方法进行扩充时。例如，该类被隐藏或者该类是终极类或者采用继承方式会产生大量的子类。
• 当需要通过对现有的一组基本功能进行排列组合而产生非常多的功能时，采用继承关系很难实现，而采用装饰器模式却很好实现。
• 当对象的功能要求可以动态地添加，也可以再动态地撤销。

装饰器模式与桥接模式的区别

第一次看装饰器模式，总感觉用桥接模式也能实现出来。但是其实两者还是有区别的。

装饰器模式的办法就是把每个子类中比基类多出来的行为放到单独的类里面。这样当这些描述额外行为的对象被封装到基类对象里面时，就得到了所需要的子类对象，将这些描述额外行为的类，排列组合可以造出很多的功能组合来，如果用静态继承的办法创建这些组合出来的类所涉及到工作量很大，以致实际上很难做到。装饰器模式要求所有的这些“额外行为类”具有相同的接口。

桥接模式的解决办法则又有所不同，桥接模式把原来的两个基类的实现化细节抽出来，再建造一个实现化的等级结构中，然后再把原有的基类改造成一个抽象化等级结构。桥接模式中抽象化角色的子类不能像装饰器模式那样嵌套，桥接模式却可以连续使用。换言之，一个桥接模式的实现化角色可以成为下一步桥接模式的抽象化角色。

装饰器模式与适配器模式的区别

装饰器与适配器都有一个别名叫做 包装模式(Wrapper)，它们看似都是起到包装一个类或对象的作用，但是使用它们的目的很不一样。适配器模式的意义是要将一个接口转变成另一个接口，它的目的是通过改变接口来达到重复使用的目的。
而装饰器模式不是要改变被装饰对象的接口，而是恰恰要保持原有的接口，但是增强原有对象的功能，或者改变原有对象的处理方式而提升性能。所以这两个模式设计的目的是不同的。

在jdk中，InputStreamReader是一个适配器，因为它把InputStream的API转换成Reader的API。InputStream是被适配的类，而 Reader是适配的目标类。InputStreamReader做为适配器类把InputStream类的一个实例包装起来,从而能够把InputStream的API。

而BufferReader是一个装饰器类，因为它实现Reader，并且包装了一个Reader。一些对流处理器可以对另一些流处理器起到装饰作用，形成新的、具有改善功能得流处理器。类似地，BufferedInputStream、OutputStream、Writer 各自都是它们自己的装饰类。LineNumberReader、FilterReader和 PushbackReader均是Reader的装饰类，因为它们自己是Reader类，而且包装其他的Reader类。CharArrayReader、FileReader、PipedReader和StringReader类不是装饰类，因为它们包装的是字符数值组、File、PipedWriter和String类。它们应该被看做字符数值组、File、PipedWriter 和String类的适配器类。