装饰者设计模式

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

【1】需求

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

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

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

4）使用OO的来计算不同种类咖啡的费用：客户可以点单品咖啡，也可以单品咖啡+调料组合。

【2】方案1-传统方式解决订单问题分析

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

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

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

4）Decaf就是单品咖啡，继承Drink，并实现cost

5）Espress&&Milk就是单品咖啡+调料，这个组合很多（组合起来就是一种咖啡，会有非常多组合，子类超级多）

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

【3】方案2-解决星巴克咖啡订单（好一些）

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

问题分析：

1）方案2可以控制类的数量，不至于造成很多的类

2）在增加或者删除调料种类时，代码的维护量很大

3）考虑到用户可以添加多份调料时，可以将hasMilk返回一个对应的int

4）考虑使用装饰者模式

2、装饰者模式定义

1）装饰者模式：动态的将新功能附加到对象上。在对象功能扩展方面，它比继承更有弹性，装饰者模式也体现了开闭原则（ocp）

2）这里提到的动态的将新功能附加到对象和ocp原则，在后面的应用实例上会以代码的形式体现，注意体会。

3、装饰者模式结构

装饰者（Decorator）模式中的角色：

抽象构件角色（Component）：定义一个抽象接口以规范准备接收附加责任的对象。比如前面的Drink。
具体构件（Concrete Component）角色：实现抽象构件，通过装饰角色为其添加一些职责。比如前面的各个单品咖啡。
抽象装饰（Decorator）角色：继承或实现抽象构件，并包含具体构件的实例，可以通过其子类扩展具体构建的功能。比如前面的各个调料。
具体装饰（ConcreteDecorator）角色：实现抽象装饰的相关方法，并给具体构件对象添加附加的责任。

4、装饰者模式原理

1）装饰者就像打包一个快递

主体：比如陶瓷、衣服（Component） // 被装饰者

包装：比如报纸填充、塑料泡沫、纸板、木板（Decorator）

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

public abstract class Component {
    public abstract void methodA();
    public abstract void methodB();
}

public class ConcreteComponent extends Component {
    public void methodA() {
    }
    
    public void methodB() {  
    }
}

public class Decorator extends Component {
    public Component obj;
    public void methodA() {
    }
    
    public void methodB() {  
    }
}

public class ConcreteDecorator extends Decorator {
    public void methodA() {
    }
    
    public void methodB() {  
    }    
}

5、装饰者模式解决星巴克咖啡问题

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();
}

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

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

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

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

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.des + " " + super.getPrice() + " && " + obj.getDes();
    }
}

// 具体的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);
    }
}

public class CoffeeBar {
    public static void main(String[] args) {
        // 装饰者模式下的订单：2份巧克力 + 一份牛奶的LongBlack
        // 1、点一份LongBlack
        Drink order = new LongBlack();
        System.out.println("费用1=" + order.cost());
        System.out.println("描述=" + order.getDes();
        
        // 2、加入一份牛奶
        order = new Milk(order);
        System.out.println("order加入一份牛奶 费用=" + order.cost());
        System.out.println("order加入一份牛奶 描述=" + order.getDes();                           
        // 3、加入一份巧克力                   
        order = new Chocolate(order);
        
        // 4、再加入一份巧克力
        order = new Chocolate(order);
    }
}

6、装饰者好处及使用场景

【1】好处

装饰者模式可以带来比继承更加灵活的扩展功能，使用更加方便，可以通过组合不同的装饰者对象来获取具有不同行为状态的多样化的结果。装饰者模式比继承更具良好的扩展性，完美的遵循开闭原则，继承是静态的附加责任，装饰者是动态的附加责任。
装饰类和被装饰类可以独立发展，不会相互耦合，装饰模式是继承的一个替代模式，装饰模式可以动态扩展一个实现类的功能。

【2】使用场景

当不能采用继承的方式对系统进行扩充或者采用继承不利于系统扩展和维护时。
不能采用继承的情况主要有两类：

第一类是系统中存在大量独立扩展，为支持每一种组合将产生大量子类，使子类数目爆炸增长。

第二类是因为类定义不能继承（如final类）
在不影响其他对象的情况下，以动态、透明的方式给单个对象添加职责。
当对象的功能要求可以动态地添加，也可以再动态地撤销时。

7、装饰者模式再JDK应用分析

【1】Java的IO结构，FilterInputStream就是一个装饰者。

public abstract class InputStream Implements Closeable {} // 抽象类，即Component

public class FilterInputStream extends InputStream { // 装饰者类Decorator
    protected volatile InputStream in; // 被装饰的对象
}

// FilterInputStream子类，也继承了被装饰的对象in
class DataInputStream extends FilterInputStream implements DataInput {}

/*
1、InputStream是抽象类，类似我们前面讲的Drink
2、FilterInputStream是InputStream子类，类似前面的LongBlack
3、FilterInputStream是InputStream子类，类似前面的Decorator修饰者
4、DataInputStream是FilterInputStream子类，具体的修饰者，类似前面的Milk
5、FilterInputStream类有protected volatile InputStream in; 即含被装饰者
*/

【2】IO流中的包装类使用到了装饰者模式。BufferedInputStream、BufferedOutputStream、BufferedReader、BufferedWriter。

我们以BufferedWriter举例来说明，先看看如何使用BufferedWriter。

public class Demo {
    public static void main(String[] args) throws Exception {
        // 创建FileWriter对象
        // 创建BufferedWriter对象
        FileWriter fw = new FileWriter("...");
        BufferedWriter bw = new BufferedWriter(fw);
        
        // 写数据
        bw.write("hello Buffered");
        bw.close();
    }
}