装饰者模式原理

咖啡馆订单项目

1. 咖啡种类：Espresso ShortBlack LongBlack Decaf
2. 调料：Milk Soy Chocolate
3. 扩展性好 改动方便 维护方便

方案一

DD0F6E67-D485-4AF7-9B83-28F1BAE90495.png

这个方案创建了一个drink的超类，然后里面添加了description用于表示咖啡的名字的信息，然后还有一个cost方法，用于返回价格

那么为什么说他是一个差的方案，所有的咖啡基类和 咖啡调料的组合，都变成了超类的子类，这简直就是类爆炸。

方案二

4D98DB14-DA64-4AAC-B9CD-7F47E3622A4F.png

这个方案解除了类爆炸，将配料作为布尔值放到了超类里面，判断是否需要添加某种调料。但是这个方案的问题是，增加删除调料种类，我需要去更改超类，而且如果我要两份奶，两份巧克力，就不能满足了，他是布尔类型的，所以也存在很大的问题

方案三 装饰者模式

010CE86C-4328-41FB-8B46-B0C844B4F9D6.png

装饰者设置了一个conponent主体抽象类，然后下面的视线一个是主体对象，一个是装饰对象，就像打包一个快递一样，核心是要邮递的东西，而外面的包装装饰是泡沫木箱等。

装饰着模式：动态的将新功能附加到对象上。在对象功能扩展方面，它比继承更有弹性。

新的项目设计方案

92EC0FF9-E1DD-4D28-ADEE-8E3CF3AA406F.png

主体类继承drink抽象类，然后装饰类继承drink后还需要添加一个Drink引用，用于接收传进来的需要包装的主体对象。

4FADAF64-723F-481A-95B1-CDD92212B95F.png

drink超类

public abstract class Drink {
    public String description="";
    private float price=0f;;
    
    
    public void setDescription(String description)
    {
        this.description=description;
    }
    
    public String getDescription()
    {
        return description+"-"+this.getPrice();
    }
    public float getPrice()
    {
        return price;
    }
    public void setPrice(float price)
    {
        this.price=price;
    }
    public abstract float cost();
    
}

下面创建一个coffee类来作为drink和咖啡子类的一个中间层，用于抽象各个咖啡都需要的一个方法，减少子类的重复代码。

public  class Coffee extends Drink {

    @Override
    public float cost() {
        // TODO Auto-generated method stub
        return super.getPrice();
    }

    
}

各个实现coffee的子类

public class Decaf extends Coffee {
    public Decaf()
    {
        super.setDescription("Decaf");
        super.setPrice(3.0f);
    }
}

public class Espresso extends Coffee{
    
    public Espresso()
    {
        super.setDescription("Espresso");
        super.setPrice(4.0f);
    }

}

public class LongBlack extends Coffee{
    
    public LongBlack()
    {
        super.setDescription("LongBlack");
        super.setPrice(6.0f);
    }

}

public class ShortBlack extends Coffee{
    
    public ShortBlack()
    {
        super.setDescription("ShortBlack");
        super.setPrice(5.0f);
    }

}

下面定义装饰者 Decorator，和coffee类一样，减少调料子类的重复代码。

public  class Decorator extends Drink {
    private Drink Obj;

    public Decorator(Drink Obj){
        this.Obj=Obj;
    };
    
    
    @Override
    public float cost() {
        // TODO Auto-generated method stub
        
        return super.getPrice()+Obj.cost();
    }

    @Override
    public String getDescription()
    {
        return super.description+"-"+super.getPrice()+"&&"+Obj.getDescription();
    }
    
    }

下面是其他的调料类

public class Milk extends Decorator {

    public Milk(Drink Obj) {        
        super(Obj);
        // TODO Auto-generated constructor stub
        super.setDescription("Milk");
        super.setPrice(2.0f);
    }
}

public class Chocolate extends Decorator {

    public Chocolate(Drink Obj) {       
        super(Obj);
        // TODO Auto-generated constructor stub
        super.setDescription("Chocolate");
        super.setPrice(3.0f);
    }

}
public class Soy extends Decorator {

    public Soy(Drink Obj) {     
        super(Obj);
        // TODO Auto-generated constructor stub
        super.setDescription("Soy");
        super.setPrice(1.5f);
    }

}

下面是一个test类

public class CoffeeBar {


    public static void main(String[] args) {
        
        Drink order;
        order=new Decaf();
        System.out.println("order1 price:"+order.cost());
        System.out.println("order1 desc:"+order.getDescription());
        
        System.out.println("****************");
        order=new LongBlack();
        order=new Milk(order);
        order=new Chocolate(order);
        order=new Chocolate(order);
        System.out.println("order2 price:"+order.cost());
        System.out.println("order2 desc:"+order.getDescription());
        
    }
}

这里需要注意的是，这里面用的是递归的思想，不断的通过类的包装，然后通过一代一代obj对象，来不断让他的price来积累，最后得到包装后的对象的价格。

Java内置的装饰者模式

B088FC45-DAA4-4084-B05B-FD7165E0C28B.png

在java中，inputStream就相当于drink超类，下面的FileInputStream StringBufferInputStream ByteArrayInputStream 相当于component子类，FilterInputStream相当于装饰类，调用的时候就会将component类装载到比如BufferInputStream缓冲区里，就是说读文件流的时候，进入缓冲然后再读取，包装到LineNumberInputStream就是按行缓冲。
这里完全用的就是装饰者的设计模式。