继承可实现功能的扩展，但如果需要拓展的功能的种类很繁多（KFC肯得基订单需求），那么势必生成很多子类。装饰者模式通过：装饰者类内部含有被装饰者（组合关系），且被装饰者与装饰者都继承自共同的父类。这样可以通过将被装饰者的子类实例对象传入-> 装饰者子类的实例对象中，拓展被装饰者继承类即可实现动态的将新功能附加到装饰者子类实例对象上。在对象功能扩展方面，它比继承更有弹性，装饰者模式也体现了开闭原则(ocp)。

一、星巴克咖啡订单项目需求

咖啡种类/单品咖啡：Espresso(意大利浓咖啡)、ShortBlack、LongBlack(美式咖啡)、Decaf(无因咖啡)
调料：Milk、Soy(豆浆)、Chocolate
要求在扩展新的咖啡种类时，具有良好的扩展性、改动方便、维护方便
使用 OOP 面象对象的来计算不同种类咖啡的费用: 客户可以点单品咖啡，也可以单品咖啡+调料组合

二、方案 1-解决星巴克咖啡订单项目（较差）

2.1 传统方案解决星巴克咖啡订单项目UML类图

较差方案：

2.2 方案 1-解决星巴克咖啡订单问题分析

Drink 是一个抽象类，表示饮料
des 就是对咖啡的描述, 比如咖啡的名字
cost() 方法就是计算费用，Drink 类中做成一个抽象方法.
Decaf 就是单品咖啡，继承 Drink, 并实现 cost
Espress && Milk 就是单品咖啡+调料，这个组合很多

问题：这样设计，会有很多类，当我们增加一个单品咖啡，或者一个新的调料，类的数量就会倍增，就会出现类爆炸

三、方案 2-解决星巴克咖啡订单（好点）

前面分析到方案 1 因为咖啡单品+调料组合会造成类的倍增，因此可以做改进，将调料内置到Drink 类，这样就不会造成类数量过多。从而提高项目的维护性(如图)

方案 2-解决星巴克咖啡订单问题分析

方案 2 可以控制类的数量，不至于造成很多的类
在增加或者删除调料种类时，代码的维护量很大
考虑到用户可以添加多份调料时，可以将 hasMilk 返回一个对应 int
考虑使用装饰者模式

四、装饰者模式定义

装饰者模式：动态的将新功能附加到对象上。在对象功能扩展方面，它比继承更有弹性，装饰者模式也体现了开闭原则(ocp)
这里提到的动态的将新功能附加到对象和 OCP 原则，在后面的应用实例上会以代码的形式体现。

4.1 装饰者模式原理

A、装饰者模式就像打包一个快递

主体：比如：陶瓷、衣服 (Component) // 被装饰者
包装：比如：报纸填充、塑料泡沫、纸板、木板(Decorator)

B、Component 主体：比如类似前面的 Drink

C、ConcreteComponent 和 Decorator

ConcreteComponent：具体的主体，比如前面的各个单品咖啡

D、Decorator: 装饰者，比如各调料

在如图的 Component 与 ConcreteComponent 之间，如果 ConcreteComponent 类很多,还可以设计一个缓冲层，将共有的部分提取出来，抽象层一个类。

4.2 装饰者模式解决星巴克咖啡订单

装饰者模式下的订单：2 份巧克力+一份牛奶的 LongBlack

AbstractDrink 源码示例：

public abstract class AbstractDrink {

    public String des; // 描述
    private float price = 0.0f;

    public String getDes() {
        return des;
    }

    public void setDes(String des) {
        this.des = des;
    }

    public float getPrice() {
        return price;
    }

    public void setPrice(float price) {
        this.price = price;
    }

    // 计算费用的抽象方法
    // 子类来实现
    public abstract float cost();
}

Coffee 源码示例：

public class Coffee extends AbstractDrink {
    @Override
    public float cost() {
        return super.getPrice();
    }
}

Espresso 源码示例：

public final class Espresso extends Coffee {
    public Espresso() {
        setDes(" 意大利咖啡 ");
        setPrice(6.0f);
    }
}

LongBlack 源码示例：

public final class LongBlack extends Coffee {
    public LongBlack() {
        setDes(" longBlack ");
        setPrice(5.0f);
    }
}

ShortBlack 源码示例：

public final class ShortBlack extends Coffee {
    public ShortBlack() {
        setDes(" shortBlack ");
        setPrice(4.0f);
    }
}

Decaf 源码示例：

public class Decaf extends Coffee {
    public Decaf() {
        setDes(" 无因咖啡 ");
        setPrice(1.0f);
    }
}

Decorator 源码示例：

public class Decorator extends AbstractDrink {
    private AbstractDrink drink;

    public Decorator(AbstractDrink drink) { // 组合
        this.drink = drink;
    }
    @Override
    public float cost() {
        // getPrice 自己价格
        return super.getPrice() + drink.cost();
    }

    @Override
    public String getDes() {
        // drink.getDes()  输出被装饰者的信息
        return super.des + " " + getPrice() + " && " + drink.getDes();
    }
}

Chocolate 源码示例：

// 具体的Decorator, 这里就是调味品
public class Chocolate extends Decorator {
    public Chocolate(AbstractDrink drink) {
        super(drink);
        setDes(" 巧克力 ");
        setPrice(3.0f); // 调味品的价格
    }
}

Milk 源码示例：

public class Milk extends Decorator {
    public Milk(AbstractDrink drink) {
        super(drink);
        setDes(" 牛奶 ");
        setPrice(2.0f);
    }
}

Soy 源码示例：

public class Soy extends Decorator {
    public Soy(AbstractDrink drink) {
        super(drink);
        setDes(" 豆浆 ");
        setPrice(1.5f);
    }
}

CoffeeBar 源码示例：

public class CoffeeBar {
    public static void main(String[] args) {
        // 装饰者模式下的订单：2份巧克力 + 一份牛奶的LongBlack

        // 1. 点一份 LongBlack
        AbstractDrink order = new LongBlack();
        System.out.println("费用1=" + order.getPrice());
        System.out.println("描述=" + order.getDes());

        // 2. order 加入一份牛奶
        order = new Milk(order);
        System.out.println("order 加入一份牛奶 费用 = " + order.cost());
        System.out.println("order 加入一份牛奶 描述 = " + order.getDes());

        // 3. order 加入一份巧克力
        order = new Chocolate(order);
        System.out.println("order 加入一份巧克力 费用 = " + order.cost());
        System.out.println("order 加入一份巧克力 描述 = " + order.getDes());

        // 4. order 加入2份巧克力
        order = new Chocolate(order);
        System.out.println("order 加入2份巧克力 费用 = " + order.cost());
        System.out.println("order 加入2份巧克力 描述 = " + order.getDes());

        System.out.println("======================================");

        AbstractDrink order2 = new Decaf();
        System.out.println("order2 无因咖啡 费用 = " + order2.cost());
        System.out.println("order2 无因咖啡 描述 = " + order2.getDes());

        order2 = new Milk(order2);
        System.out.println("order2 无因咖啡 加入一份牛奶 费用 = " + order2.cost());
        System.out.println("order2 无因咖啡 加入一份牛奶 描述 = " + order2.getDes());

    }
}

运行结果，如下：

五、装饰者模式在 JDK 应用的源码分析

Java 的 IO 结构，FilterInputStream 就是一个装饰者

package com.java.z_exam.design_patterns.c04_decorator.jdk;

/**
 * @Author:
 * @Date: Created in 11:32 上午 2020/9/2
 * @Version: 1.0
 * @Modified By:
 * @Description:
 */
import java.io.DataInputStream;
import java.io.FileInputStream;


public class Decorator {

    public static void main(String[] args) throws Exception{

        //说明
        //1. InputStream  是抽象类,  类似我们前面讲的 Drink
        //2. FileInputStream 是	InputStream  子类，类似我们前面的 DeCaf, LongBlack
        //3. FilterInputStream	是	InputStream 子类：类似我们前面 的 Decorator 修饰者
        //4. DataInputStream  是 FilterInputStream  子类，具体的修饰者，类似前面的 Milk, Soy 等
        //5. FilterInputStream 类  有	protected volatile InputStream in;  即含被装饰者
        //6. 分析得出在 jdk 的 io 体系中，就是使用装饰者模式

        DataInputStream dis = new DataInputStream(new FileInputStream("d:\\abc.txt"));
        System.out.println(dis.read());
        dis.close();
    }
}

六、装饰模式的应用

6.1 装饰者模式何时使用

在不想增加很多子类的情况下扩展类时

6.2 装饰者模式方法

将具体功能职责划分，同时继承装饰者模式

5.3 装饰者模式优点

装饰类和被装饰类可以独立发展，而不会相互耦合。它有效地把类的核心职责和装饰功能分开了
装饰模式是继承关系的一个替代方案
装饰模式可以动态地扩展一个实现类的功能

6.4 装饰者模式缺点

多层装饰比较复杂。比如我们现在有很多层装饰，出了问题，一层一层检查，最后发现是最里层的装饰出问题了，想想工作量都害怕

6.5 装饰者模式使用场景

需要扩展一个类的功能时
需要动态地给一个对象增加功能，并可以动态地撤销时
需要为一批的兄弟类进行改装或加装功能时

6.6 装饰者模式应用实例

旧机包装成新机，手机/电脑内部配件不变，只是换个外壳
换衣小游戏，人还是那个人，不断给她换衣服，还可以一层套一层的
孙悟空有72变，变成什么后就有了它的功能，但本质还是一只猴子

七、大白话小结

文章最后，给大家推荐一些受欢迎的技术博客链接：

欢迎扫描下方的二维码或搜索公众号“大数据高级架构师”，我们会有更多、且及时的资料推送给您，欢迎多多交流！

设计模式 —— 装饰者模式