结构型模式之装饰者模式

概述：

我们先来看一个快餐店的例子。

快餐店有炒面、炒饭这些快餐，可以额外附加鸡蛋、火腿、培根这些配菜，当然加配菜需要额外加钱，每个配菜的价钱通常不太一样，那么计算总价就会显得比较麻烦。

类图如下：

使用继承的方式存在的问题：

* 扩展性不好

如果要再加一种配料（火腿肠），我们就会发现需要给FriedRice和FriedNoodles分别定义一个子类。如果要新增一个快餐品类（炒河粉）的话，就需要定义更多的子类。

* 产生过多的子类

定义：指在不改变现有对象结构的情况下，动态地给该对象增加一些职责（即增加其额外功能）的模式。

结构

装饰（Decorator）模式中的角色：

* 抽象构件（Component）角色 ：定义一个抽象接口以规范准备接收附加责任的对象。
* 具体构件（Concrete  Component）角色 ：实现抽象构件，通过装饰角色为其添加一些职责。
* 抽象装饰（Decorator）角色 ： 继承或实现抽象构件，并包含具体构件的实例，可以通过其子类扩展具体构件的功能。
* 具体装饰（ConcreteDecorator）角色 ：实现抽象装饰的相关方法，并给具体构件对象添加附加的责任。

案例

我们使用装饰者模式对快餐店案例进行改进，体会装饰者模式的精髓。

类图如下：

 代码如下：

/**
 * @author: xuzhilei
 * @create: 2022-01-04
 * @description: 抽象快餐类
 **/
public abstract class FastFood {
    /**
     * 价格
     */
    private float price;
    /**
     * 描述
     */
    private String desc;

    public FastFood() {
    }

    public FastFood(float price, String desc) {
        this.price = price;
        this.desc = desc;
    }

    public float getPrice() {
        return price;
    }

    public void setPrice(float price) {
        this.price = price;
    }

    public String getDesc() {
        return desc;
    }

    public void setDesc(String desc) {
        this.desc = desc;
    }

    /**
     * 计算快餐总价
     *
     * @return 总价钱
     */
    public abstract float cost();
}

/**
 * @author: xuzhilei
 * @create: 2022-01-04
 * @description: 炒米
 **/
public class FriedRice extends FastFood {

    public FriedRice(){
        super(10,"炒米");
    }
    /**
     * 炒米总价
     * @return 总价
     */
    @Override
    public float cost() {
        return this.getPrice();
    }
}

/**
 * @author: xuzhilei
 * @create: 2022-01-04
 * @description: 炒面
 **/
public class FriedNoodles extends FastFood{

    public FriedNoodles() {
        super(12,"炒面");
    }
    /**
     * 炒面总价
     * @return 总价
     */
    @Override
    public float cost() {
        return this.getPrice();
    }
}

/**
 * @author: xuzhilei
 * @create: 2022-01-04 
 * @description: 抽象装饰类
 **/
public abstract class Garnish extends FastFood {

    private FastFood fastFood;

    protected Garnish(FastFood fastFood,float price,String desc){
        super(price,desc);
        this.fastFood = fastFood;
    }

    public FastFood getFastFood() {
        return fastFood;
    }

    public void setFastFood(FastFood fastFood) {
        this.fastFood = fastFood;
    }

}

/**
 * @author: xuzhilei
 * @create: 2022-01-04 
 * @description: 鸡蛋配料类（具体装饰者类）
 **/
public class Egg extends Garnish {

    protected Egg(FastFood fastFood) {
        super(fastFood, 1, "鸡蛋");
    }

    /**
     * 计算快餐价格+配料价格
     *
     * @return 快餐价格+配料价格之和
     */
    @Override
    public float cost() {
        return this.getPrice() + this.getFastFood().cost();
    }

    /**
     * 重写描述方法
     *
     * @return 快餐+配料后的描述
     */
    @Override
    public String getDesc() {
        return super.getDesc() + this.getFastFood().getDesc();
    }
}

/**
 * @author: xuzhilei
 * @create: 2022-01-04 
 * @description: 培根配料（具体装饰类）
 **/
public class Bacon extends Garnish {

    protected Bacon(FastFood fastFood) {
        super(fastFood, 2, "培根");
    }

    /**
     * 计算快餐价格+配料价格
     *
     * @return 快餐价格+配料价格之和
     */
    @Override
    public float cost() {
        return this.getPrice() + this.getFastFood().cost();
    }

    /**
     * 重写描述方法
     *
     * @return 快餐+配料后的描述
     */
    @Override
    public String getDesc() {
        return super.getDesc() + this.getFastFood().getDesc();
    }
}

/**
 * @author: xuzhilei
 * @create: 2022-01-04
 * @description: 测试类
 **/
public class Client {
    public static void main(String[] args) {
        //点一份炒米
        FastFood food = new FriedRice();
        System.out.println("炒米的价格：" + food.cost());
        //点一份加鸡蛋的炒米
        FastFood food1 = new FriedRice();
        food1 = new Egg(food1);
        System.out.println("炒米加一个鸡蛋的价格" + food1.cost());
        //再加一个鸡蛋
        food1 = new Egg(food1);
        System.out.println("炒米加两个鸡蛋的价格" + food1.cost());
        System.out.println(food1.getDesc());

        System.out.println("-------------------------------------");

        //点一份炒面
        FastFood food2 = new FriedNoodles();
        System.out.println("炒面的价格：" + food2.cost());
        //点一份加培根的炒面
        FastFood food3 = new FriedNoodles();
        food3 = new Bacon(food3);
        food3 = new Bacon(food3);
        System.out.println("炒面加两个培根的价格：" + food3.cost());
        System.out.println(food3.getDesc());

    }
}

测试结果：

好处：

* 饰者模式可以带来比继承更加灵活性的扩展功能，使用更加方便，可以通过组合不同的装饰者对象来获取具有不同行为状态的多样化的结果。装饰者模式比继承更具良好的扩展性，完美的遵循开闭原则，继承是静态的附加责任，装饰者则是动态的附加责任。

* 装饰类和被装饰类可以独立发展，不会相互耦合，装饰模式是继承的一个替代模式，装饰模式可以动态扩展一个实现类的功能。

与各位CSDN的伙伴们共勉，每天记录一点点，每天进步一点点