java装饰器设计模式 java 装饰器

什么是装饰器模式？

装饰器模式允许你向一个现有的对象添加新的功能，同时又不改变其结构，它是作为现有的类的一个包装。这种模式创建了一个装饰类，用来包装原有的类，并在保持类方法签名完整性的前提下，提供了额外的功能。

他的目的主要是动态地给一个对象添加一些额外的职责。就增加功能来说，装饰器模式相比生成子类更为灵活。

他主要解决的问题是我们为了扩展一个类经常使用继承方式实现，由于继承为类引入静态特征，并且随着扩展功能的增多，子类会很膨胀。

那么我们何时使用呢？

在不想增加很多子类的情况下扩展类。

如何解决？

将具体功能职责划分，同时继承装饰者模式。

关键代码：

1、Component 类充当抽象角色，不应具体实现。

2、修饰类(Decorator)引用和继承 Component 类

3、具体扩展类(ConcreteComponent)继承 Component 类，重写父类方法。

示例代码

我们去咖啡馆点咖啡的时候，通常会点具体的咖啡单品，然后再点一些咖啡调料。

咖啡种类(具体类)：Espresso、ShortBlack、LongBlack、Decaf

调料(装饰类)：Milk、Soy、Chocolate

1、抽象接口

// 饮料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();
}
2、定义具体类
咖啡父类
// 咖啡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);
}
}
3、定义装饰类
调料父类
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}====]====]====]

总结

优点：

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