设计模式之装饰者模式（结合实例+在JDK源码中的使用）

跟着完成项目过程中，接触到了装饰者模式，借此机会，了解下。
学习来源：韩顺平老师讲解的23种设计模式

一、原理

（一）定义

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

开闭原则：一个软件实体应该通过扩展来实现变化，而不是通过修改已有的代码来实现变化。

（二）原理图

场景：去买咖啡(Drink)，咖啡有Espresso，LongBlack，ShortBlack，DeCaf这几种；还可以加料：Chocolate，Milk，Soy。

成员介绍

1. Component。它是一个抽象类，就是上述场景中的Drink
2. ConcreteComponent。具体的主体，继承了Component。Espresso，LongBlack，ShortBlack，DeCaf就是具体的主体
3. Decorator。装饰者，包含主体（Component）的.上述例子中的加料：Chocolate，Milk，Soy
4. 在类图中Component和ConcreteComponent之间，如果具体实现有很多，可以在中间加一个缓冲层，将共有的部分提取出来，抽象成一个类。（原因是：抽象方法在子类必须要实现。如果有一个缓冲层继承了Component，实现它的抽象方法。其余ConcreteComponent直接继承缓冲层，不再需要实现Component中的抽象方法了。缓冲层就是承上启下的作用）

二、实际中使用方式

还是以之前的咖啡为例，类的设计描述如下：

Drink是主体，有一个抽象方法cost()。Coffee()是缓冲层，继承Drink，实现它的cost()方法。具体的主体ShortBlack，Decaf，Espresso，LongBlack继承Coffee，在他们的构造方法中设置初始值。

Decorator是装饰者，含有一个被装饰的对象（Drink），且继承Drink，重写它的cost()方法，进行一个费用的叠加计算，递归的计算价格。

Milk，Chocolate，Soy继承Decorator

具体下订单案例：2份巧克力+一份牛奶的LongBlack

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

实操

1. 主体。Drink.class

//单品咖啡
public abstract class Drink {

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

   public String getDesc() {
       return desc;
   }

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

   public void setDesc(String desc) {
       this.desc = desc;
   }
   public float getPrice() {
       return price;
   }
   public void setPrice(float price) {
       this.price = price;
   }

}

2. 缓冲层。Coffee.class，降低实现具体类的工作量。

public class Coffee extends Drink {

   @Override
   public float cost() { //实现主体的抽象方法
       return super.getPrice();
   }
}

3. 具体实现。LongBlack .class

public class LongBlack extends Coffee {

   public LongBlack() {
       setDesc("Long Black");
       setPrice(5.0f);
   }
}

4. 装饰者。Decorator.class

public class Decorator extends Drink {
   private Drink obj;

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

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

   @Override
   public String getDesc() {
       // 父类的描述信息 + 父类的价格 + 组合(被装饰者)的描述信息
       return desc + " "+ getPrice() + " && " + obj.getDesc();
   }
}

5. Milk.class

public class Milk extends Decorator {
    public Milk(Drink obj) {
        super(obj);
        setDesc("牛奶");
        setPrice(2.0f);
    }
}

6. Chocolate .class

public class Chocolate extends Decorator {

    public Chocolate(Drink obj) {
        super(obj);
        setDesc("巧克力");
        setPrice(3.0f);//调味品的价格
    }
}

7. 装饰者模式下订单

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.getDesc());

        //2. order 加入一份牛奶
        order = new Milk(order);

        System.out.println("order 加入一份牛奶，费用 =  " + order.cost());
        System.out.println("点单情况： " + order.getDesc());

        //3. order 加入一份巧克力
        order = new Chocolate(order);
        System.out.println("order 加入一份牛奶，再加入一份巧克力。费用 =  " + order.cost());
        System.out.println("点单情况： " + order.getDesc());

        //4. order 再加入一份巧克力
        order = new Chocolate(order);
        System.out.println("order 加入一份牛奶，再加入一份巧克力，再加入一份巧克力。费用 =  " + order.cost());
        System.out.println("点单情况：  " + order.getDesc());
            }
}

结果：

三、JDK源码中的使用分析

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

1. 主体：InputStream.class，它是个抽象类，包含抽象方法，就像前面的Drink。
   public abstract int read() throws IOException;
2. 具体的主体：FileInputStream，StringBufferInputStream等等，类似于上面的单品咖啡。
3. 装饰者：FilterInputStream。这里会有混淆，同样都继承了InputStream，一个是主体，一个是装饰者。区别在于FilterInputStream即继承了InputStream，又包含了InputStream，是继承+组合的方式
   
4. BufferInputStream具体的装饰者，就像上面的调味品了，继承了FilterInputStream。