设计模式之装饰者模式

基本介绍

装饰者模式：动态的将新功能附加到对象上，在对象功能扩展方面，它比继承更具有弹性，装饰者模式也体现了开闭原则

结构

1. 装饰者模式就像打包一个快点
2. 主体：被装饰者
3. 包装：装饰者

模拟场景：咖啡，加配料

分几个部分
1.Drink：抽象类，包含描述和价格，加上计算价格的抽象方法
2.Drink抽象实现类：被装饰者
3.Decorator：实现了Drink，并且组合了Drink，装饰者

Drink:

public abstract class Drink {

    public String des;

    private float price = 0.0f;

    // 计算费用的抽象方法
    public abstract float cost();

    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 class LongBlack extends Coffee{
    public LongBlack() {
        setDes("美式咖啡");
        setPrice(25.0f);
    }
}

public class ShortBlack extends Coffee{
    public ShortBlack() {
        setDes("ShortBlack");
        setPrice(30.0f);
    }
}

装饰者父类

public class Decorator extends Drink{

    private Drink drink;

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

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

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

装饰者实现

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

public class Soy extends Decorator{

    public Soy(Drink drink) {
        super(drink);
        setDes("豆浆");
        setPrice(3.0f);
    }
}

public class Chocolate extends Decorator{

    public Chocolate(Drink drink) {
        super(drink);
        setDes("巧克力");
        setPrice(5.0f);
    }
}

模拟订单

public class CoffeeBar {
    public static void main(String[] args) {
        // 装饰者下订单
        Drink order = new LongBlack();
        System.out.println(order.getDes() + " 费用1：" + order.cost());
        // 加入牛奶
        order = new Milk(order);
        System.out.println(order.getDes() + " 费用1：" + order.cost());
        // 加入巧克力
        order = new Chocolate(order);
        System.out.println(order.getDes() + " 费用1：" + order.cost());

    }
}

总结

如果只是看装饰者模式的实现，你不会发现有什么特别的地方，但是如果你在正常的场景下，你会发现，你会遇到各种可能，不是类爆炸，就是难以维护，继承也不一定是一个好维护的办法。
使用装饰者模式，你会发现，如果我想要添加新的饮料，我只需要添加一个类，然后继承Drink就可以实现，不需要因为不同的配料而产生大量的类或者代码。
这种方式更便于你去维护和扩展