带你一次性搞懂软件构造中的装饰者模式

星巴克咖啡订单项目（咖啡馆）：

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

装饰者模式定义

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

装饰者模式原理

1. 装饰者模式就像打包一个快递
   主体：比如：陶瓷、衣服(Component) // 被装饰者
   包装：比如：报纸填充、塑料泡沫、纸板、木板(Decorator)

2. Component 主体：比如类似前面的Drink

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

   Decorator: 装饰者，比如各调料.在如图的Component 与ConcreteComponent之间，如果ConcreteComponent 类很多,还可以设计一个缓冲层，将共有的部分提取出来，抽象层一个类。

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

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

说明：

1. Milk包含了LongBlack
2. 一份Chocolate包含了(Milk+LongBlack)
3. 一份Chocolate包含了(Chocolate+Milk+LongBlack)
4. 这样不管是什么形式的单品咖啡+调料组合，通过递归方式可以方便的组合和维护。

装饰者模式的另一个具体案例

来考虑一个做手抓饼的程序：我们需要为每一种手抓饼生成出一个类。手抓饼是从基础手抓饼做起，然后可选地添加培根、火腿、蛋、土豆丝、鸡排……例如“加培根加火腿的手抓饼”、“加鸡排的手抓饼”。朴素手抓饼价格为 CNY 5；每种配料有自己的价格。

显然，如果有 n 种配料，那我们得有 2n 个类与之对应。如果有 10 种配料，那么类的个数会达到 1024 个。这是不可接受的，称为“组合爆炸”。

装饰模式(decorator pattern)是为了解决组合爆炸而生的。它将我们需要的类的个数，从 O(2n) 降低到 O(n)；相应地，我们必须精细地设计接口，来保证装饰模式可以工作。这里我们演示“造手抓饼”和“计算手抓饼的价格”两个方法。

装饰模式的角色如下：

• 抽象构件（实现为接口或者抽象类）。定义了所有手抓饼的接口。
• 具体构件。基础的手抓饼，它可以被装饰。一个系统可以有多个具体构件，例如朴素手抓饼可能有多个品牌的。
• 抽象装饰类。装饰的起点，用于包装一个手抓饼。它是抽象构件的子类。
• 具体装饰类。负责为手抓饼增加具体的功能。

现在我们来看一个例子。手抓饼的抽象构件和具体构件如下：

interface Cake {
    public int getPrice();
}

class BasicCake implements Cake {
    public BasicCake() {
        System.out.println("Make a basic cake");
    }

    public int getPrice() {
        return 5;
    }
}

然后实现一个抽象装饰类，委派一个 cake ：

class CakeDecorator implements Cake {
    private Cake cake;

    public CakeDecorator(Cake cake) {
        this.cake = cake;
    }

    public int getPrice() {
        return cake.getPrice();
    }
}

从而 CakeDecorator 的子类，可以对任何一个 Cake 进行装饰。来做两种配料：

class addBacon extends CakeDecorator {
    public addBacon(Cake cake) {
        super(cake);
        System.out.println(" + bacon");
    }

    @Override
    public int getPrice() {
        return super.getPrice() + 2;
    }
}

class addPotato extends CakeDecorator {
    public addPotato(Cake cake) {
        super(cake);
        System.out.println(" + potato");
    }

    @Override
    public int getPrice() {
        return super.getPrice() + 1;
    }
}

客户端代码如下：

public class Main {
    public static void main(String[] args) {
        Cake baconCake = new addBacon(new BasicCake());
        System.out.println("CNY " + baconCake.getPrice());

        Cake potatoCake = new addPotato(new BasicCake());
        System.out.println("CNY " + potatoCake.getPrice());

        Cake fullCake = new addBacon(new addPotato(new BasicCake()));
        System.out.println("CNY " + fullCake.getPrice());
    }
}

最后输出了我们想要的结果。

Make a basic cake
 + bacon
CNY 7
Make a basic cake
 + potato
CNY 6
Make a basic cake
 + potato
 + bacon
CNY 8

总结

有抽象的意识：有相同特征的就会被抽象出来如：上面讲的把他们抽象成饮料类和调味类，再根据适合的设计模式

抽象父类 Drink
抽象子类 Decorator

上面的装饰者模式其实就是：抽象子类(抽象父类)