设计模式之装饰者模式

装饰者模式

案例展示：

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

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

方案1-解决星巴克咖啡订单项目

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

1. Drink 是一个抽象类，表示饮料
2. des就是对咖啡的描述, 比如咖啡的名字
3. cost() 方法就是计算费用，Drink 类中做成一个抽象方法.
4. Decaf 就是单品咖啡， 继承Drink, 并实现cost
5. Espress && Milk 就是单品咖啡+调料， 这个组合很多
6. 问题：这样设计，会有很多类，当我们增加一个单品咖啡，或者一个新的调料，
   类的数量就会倍增，就会出现类爆炸

装饰者模式定义

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

装饰者模式原理：

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

用装饰者模式设计的方案：

代码实现：

Drink类--抽象类

/**
 * @author 孙一鸣 on 2020/2/10
 */
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();
}

缓冲层：

/**
 * 缓冲层
 *
 * @author 孙一鸣 on 2020/2/10
 */
public class Coffee extends Drink {
    @Override
    public float cost() {
        return super.getPrice();
    }
}

这个缓冲类使用了super关键字
解析super关键字：
一.super关键字作用

1：主要存在于子类方法中，用于指向子类对象中父类对象。
2：访问父类的属性
3：访问父类的函数
4：访问父类的构造函数

二.super注意的地方

super指向的是当前调用对象的父类。类加载完毕，创建对象，父类的构造方法会被调用（默认自动无参），然后执行子类相应构造创建了一个子类对象，该子类对象还包含了一个父类对象。该父类对象在子类对象内部。this super只能在有对象的前提下使用，不能在静态上下文使用。

三.super关键字的使用

1.子类的构造函数默认第一行会默认调用父类无参的构造函数，隐式语句

三种咖啡全是抽象类Drink的子类
意大利咖啡：

/**
 * @author 孙一鸣 on 2020/2/10
 */
public class Espresso extends Coffee {

    public Espresso() {
        setDes("意大利咖啡");
        setPrice(6f);
    }
}

美式咖啡:

/**
 * @author 孙一鸣 on 2020/2/10
 */
public class LongBlack extends Coffee {

    public LongBlack() {
        setDes("美式咖啡");
        setPrice(5.0f);
    }
}

short咖啡：

/**
 * @author 孙一鸣 on 2020/2/10
 */
public class ShortBlack extends Coffee {

    public ShortBlack() {
        setDes("short咖啡");
        setPrice(4.0f);
    }
}

---

Decorator 是一个装饰类，含有一个被装饰的对象(Drink obj)

/**
 * @author 孙一鸣 on 2020/2/10
 */
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();
    }
}

@Override
public String getDes() {
return super.des + " "+super.getPrice() + obj.getDes();
根据Debug方式得到、
这里调用super.getPrice 即调用父类Drink的getPrice
此时的父类 属性已经有值
public String des; = 牛奶//描述
private float price=2.0f;

装饰类：巧克力：

/**
 * @author 孙一鸣 on 2020/2/10
 */
public class Chocolate extends Decorator {
    public Chocolate(Drink obj) {
        super(obj);
        setDes("巧克力");
        setPrice(3.0f);
    }
}

装饰类：牛奶：

/**
 * @author 孙一鸣 on 2020/2/10
 */
public class Milk extends Decorator {
    public Milk(Drink obj) {
        super(obj);
        setDes("牛奶");
        setPrice(2.0f);
    }
}

装饰类：豆浆：

/**
 * @author 孙一鸣 on 2020/2/10
 */
public class Soy extends Decorator {
    public Soy(Drink obj) {
        super(obj);
        setDes("豆浆");
        setPrice(1.5f);
    }
}

调用：

/**
 * @author 孙一鸣 on 2020/2/10
 */
public class CoffeeBar {
    public static void main(String[] args) {
        Drink order=new LongBlack();
        System.out.println("费用1："+order.cost());
        System.out.println("描述信息:"+order.getDes());

         order = new Milk(order);
        System.out.println("费用1："+order.cost());
        System.out.println("描述信息:"+order.getDes());

        order =new  Chocolate(order);
        order =new  Chocolate(order);
        System.out.println("费用1："+order.cost());
        System.out.println("描述信息:"+order.getDes());

    }
}

演示截图:

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

public abstract class InputStream implements Closeable{} //是一个抽象类，即Component
public class FilterInputStream extends InputStream { //是一个装饰者类Decorator
protected volatile InputStream in //被装饰的对象 }
class DataInputStream extends FilterInputStream implements DataInput { //FilterInputStream 子类，