装饰者模式

咖啡订单项目：

​ 咖啡种类：Espresso、ShortBlack、LongBlack、Decaf
​
 调料：Mike、Soy、Chocolate
​
 要求：在拓展新咖啡种类时，具有较好的扩展性、改动方便、维护方便

​ 使用OO的方式计算不同种类的费用，可有单点，也可单点+调料组合

方案1：

​
​   Drink:抽象类，表示饮料

​     description:对咖啡的描述，不然咖啡的名字

​     cost():计算费用，由具体实现类实现。

​ 问题：

​   该设计需要许多类，当增加一个新种类或者新调料时，则需要增加更多的类，易导致类爆炸。

 

方案二：

​

​   将配料作为饮料的属性，则减少了许多类的产生

​   但在增加或者删除种类，代码的维护量很大。

 

装饰者模式

  允许你通过将对象放入包含行为的特殊封装对象中来为原对象绑定新的行为。动态地将新功能附加在对象上。

装饰模式结构

  1.部件 （Component） 声明封装器和被封装对象的公用接口。
  2.具体部件 （Concrete Component） 类是被封装对象所属的类。 它定义了基础行为， 但装饰类可以改变这些行为。
  3.基础装饰 （Base Decorator） 类拥有一个指向被封装对象的引用成员变量。 该变量的类型应当被声明为通用部件接口， 这样它就可以引用具体的部件和装饰。 装饰基类会将所有操作委派给被封装的对象。
  4.具体装饰类 （Concrete Decorators）定义了可动态添加到部件的额外行为。 具体装饰类会重写装饰基类的方法， 并在调用父类方法之前或之后进行额外的行为。
  5.客户端 （Client） 可以使用多层装饰来封装部件， 只要它能使用通用接口与所有对象互动即可。
 

装饰模式适合应用场景

  1.如果你希望在无需修改代码的情况下即可使用对象， 且希望在运行时为对象新增额外的行为， 可以使用装饰模式。

  2.如果用继承来扩展对象行为的方案难以实现或者根本不可行， 你可以使用该模式。
 

实现方式

  1.确保业务逻辑可用一个基本组件及多个额外可选层次表示。

  2.找出基本组件和可选层次的通用方法。 创建一个组件接口并在其中声明这些方法。

  3.创建一个具体组件类， 并定义其基础行为。

  4.创建装饰基类， 使用一个成员变量存储指向被封装对象的引用。 该成员变量必须被声明为组件接口类型， 从而能在运行时连接具体组件和装饰。 装饰基类必须将所有工作委派给被封装的对象。

  5.确保所有类实现组件接口。

  6.将装饰基类扩展为具体装饰。 具体装饰必须在调用父类方法 （总是委派给被封装对象） 之前或之后执行自身的行为。

  7.客户端代码负责创建装饰并将其组合成客户端所需的形式。
 

装饰模式优缺点

  优点：
    ✔️​你无需创建新子类即可扩展对象的行为。
    ✔️​你可以在运行时添加或删除对象的功能。
    ✔️​你可以用多个装饰封装对象来组合几种行为。
    ✔️​单一职责原则。 你可以将实现了许多不同行为的一个大类拆分为多个较小的类。
  缺点：
    ❌在封装器栈中删除特定封装器比较困难。
    ❌实现行为不受装饰栈顺序影响的装饰比较困难。
    ❌各层的初始化配置代码看上去可能会很糟糕。

 

更改后的咖啡订单

​

装饰者模式下如何表示：2份巧克力+1份牛奶的LongBlack

​chocolate->chocolate->Milk->LongBlack

采用递归的方式来组成。便可以组成任意的单品咖啡+调料组合

代码：

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 DeCaf  extends Coffee{
    public DeCaf(){
        setDes("无因咖啡");
        setPrice(1.0f);
    }
}

public class Decorator extends Drink{
    private Drink drink;

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

    public float cost(){
        //super.Price == 自己的价格
        return super.getPrice()+drink.cost();
    }

    @Override
    public String getDes() {
        return des+" "+":"+getPrice()+"+"+drink.getDes();
    }
    
}

public class Chocolate extends Decorator {
    public Chocolate(Drink drink) {
        super(drink);
        setDes("巧克力");
        setPrice(3.0f);
    }
}

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

public class Soy extends Decorator {
    public Soy(Drink drink) {
        super(drink);
        setDes("豆浆");
        setPrice(1.5f);
    }
}

public class CofferBar {
    public static void main(String[] args) {
        //2份巧克力+1份牛奶的 LongBlack

        //LongBlack
        Drink drink = new LongBlack();
        System.out.println("目前情况"+drink.getDes());
        System.out.println("花费+"+drink.cost());

        //+Milk
        drink = new Milk(drink);


        System.out.println("目前情况"+drink.getDes());
        System.out.println("花费+"+drink.cost());

        //+2份巧克力
        for (int i = 0; i < 2; i++) {
            drink = new Chocolate(drink);
        }
        System.out.println("目前情况"+drink.getDes());
        System.out.println("花费+"+drink.cost());

		 /*
            花费+5.0
            目前情况LongBlack
            花费+7.0
            目前情况牛奶 :2.0+LongBlack
            花费+13.0
            目前情况巧克力 :3.0+巧克力 :3.0+牛奶 :2.0+LongBlack
         */
    }
}