装饰者模式笔记

装饰者模式

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

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

方案2-解决星巴克咖啡订单（好点）
前面分析到方案1因为咖啡单品+调料组合会造成类的倍增，因此可以做改进，将调料内置到Drink类，这样就不会造成数量过多，从而提高项目的维护性
说明：milk、soy、chocolate可以设计为Boolean，表示是否要添加相应的调料
1.方案2可以控制类的数量，不至于造成很多的类
2.在增加或者删除调料种类时，代码的维护量还是很大
3.考虑到用户可以调价多分调料时，可以将hasMilk返回一个对应的int
4.考虑使用装饰者模式

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

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

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

用装饰者模式设计的方案
1.Drink类就是前面说的抽象类，Component
2.ShortBlack就是单品咖啡
3.Decorator是一个装饰类，含有一个被装饰的对象（Drink obj）
4.Decorator的cost方法进行一个费用的叠加计算，递归的计算价格

装饰者模式的下的订单：2分巧克力+一份牛奶的LongBlack
1.Milk包含了LongBlack
2.一份Chocolate包含了Milk+LongBlack
3.一份Chocolate包含了Chocolate+Milk+LongBlack
4.这样不管是什么形式的单品咖啡+调料组合，通过递归方式可以方便的组合和维护

@Getter
@Setter
public abstract class Drink{
    public String des;
    private float price = 0.0f;

    public abstract float cost();
}

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

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

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

public DeCaf extends Coffee{
    public DeCaf(){
        setDes("无因咖啡");
        setPrice(1.0);
    }
}

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

public class Decorator extends Drink{
    public Drink obj;
    
    public Decorator(){
        this.obj = obj;
    }

    @Override
    public float cost(){
        return super.getPrice() + obj.cost(); 
    }

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

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){
        Drink order = new LongBlack();
        System.out.println(" 费用= " + order.cost());

        order = new Milk(order);
        order = new Chocolate(order);
        order = new Chocolate(order);
        System.out.println(" 费用= " + order.cost());
        System.out.println(" 描述= " + order.getDes());

        Drink order2 = new DeCaf();
    }
}

装饰者模式在JDK应用的源码分析
Java的IO结构，FilterInputStream就是一个装饰者
1.InputStream是抽象类，类似我们前面讲的Drink
2.FileInputStream是InputStream子类，类似我们前面的DeCaf，LongBlack
3.FilterInputStream是InputStream子类：类似我们前面的Decorator修饰者
4.DataInputStream是FilterInputStream子类，具体的修饰者，类似前面的Milk，soy等
5.FilterInputStream类有protected volatile InputStream in；即含被装饰者
6.分析得出在jdk的io体系中，就是使用装饰者模式