设计模式-装饰者模式

1. 具体需求

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

1）咖啡种类/单品咖啡：Espresso（意大利浓咖啡）、ShortBlack、LongBlack（美式咖啡）、Decaf（无因咖啡）

2）调料：Milk、Soy（豆浆）、Chocolate

3）要求在扩展新的咖啡种类时，具有良好的扩展性、改动方便、维护方便

4）使用OO的来计算不同种类咖啡的费用：客户可以单点咖啡+调料组合（美式+2份Chocolate）

2. 解决方案1

问题分析：

1）Drink是一个抽象类，表示饮料

2）des就是对咖啡的描述，比如咖啡的名字

3）cost()方法就是计算费用，Drink类中做成一个抽象方法

4）Decaf就是单品咖啡，继承Drink，并实现cost，其他的单品一次类推

5）Express&&Milk就是单品咖啡+调料，这个组合很多

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

3. 解决方案2

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

说明：milk、soy、chocolate可以设计为Boolean，表示是否要添加相应的调料

2）问题分析

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

4. 装饰者模式

4.1 基本介绍

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

4.2 原理

装饰者模式就像打包一个快递主体：比如：陶瓷、衣服(Component)//被装饰者包装：比如：报纸填充、塑料泡沫、纸板、木板//Decorator装饰者 1）Component：主体，比如类似前面的 Drink 2）ConcreteComponent：具体的主体，比如前面的各个单品咖啡 3）Decorator：装饰者，比如各调料在如图的 Component 与 ConereteComponent 之间，如果 ConcreteComponent 类很多,还可以设计一个缓冲层，将共有的部分提取出来，抽象成一个类。

5. 装饰者模式解决方案

设计方案

说明：

Drink类就是前面说的抽象类，Component
Coffee缓冲类，继承了Drink
ShortBlack就是单品咖啡，ConcreteComponent，继承Component
Decorator是一个装饰类，含有一个被装饰的对象（Drink obj）
Decorator的cost方法，进行一个费用的叠加计算，递归的计算价格
Chocolate就是一个具体的装饰类，装饰者，继承Decorator，重写cost方法

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

说明：
- Milk包含了LongBlack
- 一份Chocolate包含了（Milk+LongBlack）
- 一份Chocolate包含了（Chocolate+Milk+LongBlack）
- 这样不管是什么形式的单品咖啡+调料组合，通过递归方式（包裹再包裹）可以方便的组合和维护
代码示例

//Component
public abstract class Drink {
    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();
}

//Component和ConcreteComponent之间的缓冲类
//将ConcreteComponent共同的部分抽出来
public class Coffee extends Drink{
    @Override
    public float cost() {
        return super.getPrice();
    }
}

//ConcreteComponent
public class Espresso extends Coffee{
    public Espresso() {
        setDes("意大利咖啡");
        setPrice(6.0f);
    }
}
//ConcreteComponent
public class LongBlack extends Coffee{
    public LongBlack() {
        setDes("美式咖啡");
        setPrice(5.0f);
    }
}
//ConcreteComponent
public class ShortBlack extends Coffee{
    public ShortBlack() {
        setDes("short black");
        setPrice(4.0f);
    }
}
//ConcreteComponent
public class Decaf extends Coffee{
    public Decaf() {
        setDes("无因咖啡");
        setPrice(8.0f);
    }
}

//Decorator
public class Decorator extends Drink{
    private Drink obj;//被装饰者

    //组合关系
    public Decorator(Drink obj) {
        this.obj = obj;
    }

    @Override
    public float cost() {
        //自己的价格+饮料的价格
        return super.getPrice() + obj.cost();
    }

    @Override
    public String getDes() {
        return super.getDes() + " " + super.getPrice() + " && " + obj.getDes();
    }
}

//ConcreteDecorator
//具体的Decorator，这里就是调味品
public class Chocolate extends Decorator{
    public Chocolate(Drink obj) {
        super(obj);
        setDes("巧克力");
        setPrice(3.0f);
    }
}
public class Milk extends Decorator{
    public Milk(Drink obj) {
        super(obj);
        setDes("牛奶");
        setPrice(2.0f);
    }
}
public class Soy extends Decorator{
    public Soy(Drink obj) {
        super(obj);
        setDes("豆浆");
        setPrice(1.5f);
    }
}

//TestClient
public class CoffeeBar {
    public static void main(String[] args) {
        //1. 点一份LongBlack
        Drink order = new LongBlack();
        System.out.print("fee1: " + order.cost());
        System.out.println(" des1: " + order.getDes());

        //2. 加一份牛奶
        order = new Milk(order);
        System.out.print("fee2: " + order.cost());
        System.out.println(" des2: " + order.getDes());

        //3. 加一份巧克力
        order = new Chocolate(order);
        System.out.print("fee3: " + order.cost());
        System.out.println(" des3: " + order.getDes());

        //4. 加一份巧克力
        order = new Chocolate(order);
        System.out.print("fee4: " + order.cost());
        System.out.println(" des4: " + order.getDes());
    }
}

6. 装饰者模式在JDK应用的源码分析

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

InputStream是一个抽象类，Component，类比Drink
FileInputStream、StringBufferInputStream、ByteArrayInputStream……是InputStream的子类，是具体的Component，类比Decaf
FilterInputStream是InputStream的另一个子类，是一个装饰者Decorator，里面有一个InputStream
BufferInputStream、DataInputStream、LineNumberInputStream是具体的Decorator