这是我参与8月更文挑战的第14天，活动详情查看：8月更文挑战
什么是装饰器模式？
装饰器模式允许你向一个现有的对象添加新的功能，同时又不改变其结构，它是作为现有的类的一个包装。这种模式创建了一个装饰类，用来包装原有的类，并在保持类方法签名完整性的前提下，提供了额外的功能。
他的目的主要是动态地给一个对象添加一些额外的职责。就增加功能来说，装饰器模式相比生成子类更为灵活。
他主要解决的问题是我们为了扩展一个类经常使用继承方式实现，由于继承为类引入静态特征，并且随着扩展功能的增多，子类会很膨胀。
那么我们何时使用呢？
在不想增加很多子类的情况下扩展类。
如何解决？
将具体功能进行职责划分，同时继承装饰者模式。
关键代码：
- 抽象构件角色（Component）充当抽象角色，不应具体实现。
- 具体构件角色（ConcreteComponent）继承 Component 类，重写父类方法。
- 具体装饰角色（Decorator） 引用和继承 Component 类。负责给构件对象“贴上”附加的责任。
示例代码
我们去咖啡馆点咖啡的时候，通常会点具体的咖啡单品，然后再点一些咖啡调料。
咖啡种类（具体类）：Espresso、ShortBlack、LongBlack、Decaf
调料（装饰类）：Milk、Soy、Chocolate
定义抽象构件接口
饮料接口
// 饮料
public abstract class Drink {
// 描述
private 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();
}
定义具体类
咖啡父类
// 咖啡
public class Coffee extends Drink {
@Override
public float cost() {
return super.getPrice();
}
}
低咖
// 低咖
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);
}
}
定义装饰类
调料父类
public class Decorator extends Drink {
private Drink drink;
public Decorator(Drink drink) {
this.drink = drink;
}
@Override
public float cost() {
return super.getPrice() + drink.cost();
}
@Override
public String getDescription() {
return "[===="+super.getDescription() + "&&" + drink.getDescription()+"====]";
}
}
巧克力
public class Chocolate extends Decorator {
public Chocolate(Drink drink) {
super(drink);
super.setDescription("Chocolate");
super.setPrice(3.0f);
}
}
牛奶
public class Milk extends Decorator {
public Milk(Drink drink) {
super(drink);
super.setDescription("Milk");
super.setPrice(2.0f);
}
}
咖啡豆
public class Soy extends Decorator {
public Soy(Drink drink) {
super(drink);
super.setDescription("Soy");
super.setPrice(1.5f);
}
}
测试
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());
}
}
运行结果：
order1 price:3.0
order1 desc:{描述：Decaf-3.0}
****************
order2 price:14.0
order2 desc:[===={描述：Chocolate-3.0}&&[===={描述：Chocolate-3.0}&&[===={描述：Milk-2.0}&&{描述：LongBlack-6.0}====]====]====]
总结
优点：
装饰类和被装饰类可以独立发展，不会相互耦合，装饰模式是继承的一个替代模式，装饰模式可以动态扩展一个实现类的功能。
缺点：
多层装饰比较复杂。
使用场景：
- 扩展一个类的功能。
- 动态增加功能，动态撤销。
注意事项：
动态的将新功能附加到对象上。在对象功能扩展方面，它比继承更有弹性，可代替继承。
