目录
1.概述
（1）我们先来看一个快餐店的例子：快餐店有炒面、炒饭这些快餐，可以额外附加鸡蛋、火腿、培根这些配菜，当然加配菜需要额外加钱，每个配菜的价钱通常不太一样，那么计算总价就会显得比较麻烦。而使用继承的方式存在的问题：
- 扩展性不好：如果要再加一种配料（火腿肠），我们就会发现需要给
FriedRice和FriedNoodles分别定义一个子类。如果要新增一个快餐品类（炒河粉）的话，就需要定义更多的子类。 - 会产生过多的子类：
（2）装饰者模式 (Decorator Pattern) 是一种结构型设计模式，它能在不改变现有对象结构的情况下，动态地给该对象增加一些职责（即增加其额外功能）。
2.结构
装饰者模式中的角色如下：
- 抽象组件 (Component) 角色：定义一个抽象接口以规范准备接收附加责任的对象。
- 具体组件 (Concrete Component) 角色：实现抽象组件，通过装饰角色为其添加一些职责。
- 抽象装饰 (Decorator) 角色：继承或实现抽象构件，并包含具体组件的实例，可以通过其子类扩展具体组件的功能。
- 具体装饰 (Concrete Decorator) 角色：实现抽象装饰的相关方法，并给具体组件对象添加附加的责任。
3.案例实现
我们使用装饰者模式对快餐店案例进行改进，体会装饰者模式的精髓。其类图如下：
3.1.抽象组件
FastFood.java
//快餐类
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;
}
public abstract float cost();
}
3.2.具体组件
FriedRice.java
//炒饭
public class FriedRice extends FastFood{
public FriedRice(){
super(10, "炒饭");
}
@Override
public float cost() {
return getPrice();
}
}
FriedNoodles.java
//炒面
public class FriedNoodles extends FastFood{
public FriedNoodles(){
super(12,"炒面");
}
@Override
public float cost() {
return getPrice();
}
}
3.3.抽象装饰
Garnish.java
//装饰者类
public abstract class Garnish extends FastFood{
//声明快餐类的变量
private FastFood fastFood;
public FastFood getFastFood() {
return fastFood;
}
public void setFastFood(FastFood fastFood) {
this.fastFood = fastFood;
}
public Garnish(FastFood fastFood, float price, String desc) {
super(price, desc);
this.fastFood = fastFood;
}
}
3.4.具体装饰
Egg.java
//鸡蛋类
public class Egg extends Garnish{
public Egg(FastFood fastFood){
super(fastFood, 1, "鸡蛋");
}
@Override
public float cost() {
//计算价格，鸡蛋价格 + 快餐价格
return getPrice() + getFastFood().cost();
}
@Override
public String getDesc() {
return super.getDesc() + getFastFood().getDesc();
}
}
Bacon.java
//培根类
public class Bacon extends Garnish{
public Bacon(FastFood fastFood){
super(fastFood, 2, "培根");
}
@Override
public float cost() {
//计算价格，培根价格 + 快餐价格
return getPrice() + getFastFood().cost();
}
@Override
public String getDesc() {
return super.getDesc() + getFastFood().getDesc();
}
}
3.5.测试
Client.java
public class Client {
public static void main(String[] args) {
//点一份炒饭
FastFood food = new FriedRice();
System.out.println(food.getDesc() + " " + food.cost() + " 元");
System.out.println("===============");
//在上面的炒饭中加一个鸡蛋
food = new Egg(food);
System.out.println(food.getDesc() + " " + food.cost() + " 元");
System.out.println("================");
//再加一个鸡蛋
food = new Egg(food);
System.out.println(food.getDesc() + " " + food.cost() + " 元");
System.out.println("================");
food = new Bacon(food);
System.out.println(food.getDesc() + " " + food.cost() + " 元");
}
}
输出结果如下：
炒饭 10.0 元
===============
鸡蛋炒饭 11.0 元
================
鸡蛋鸡蛋炒饭 12.0 元
================
培根鸡蛋鸡蛋炒饭 14.0 元
在上述例子中使用装饰者模式至少有以下优点：
- 饰者模式可以带来比继承更加灵活性的扩展功能，使用更加方便，可以通过组合不同的装饰者对象来获取具有不同行为状态的多样化的结果。装饰者模式比继承更具良好的扩展性，完美的遵循开闭原则，继承是静态的附加责任，装饰者则是动态的附加责任。
- 装饰类和被装饰类可以独立发展，不会相互耦合，装饰模式是继承的一个替代模式，装饰模式可以动态扩展一个实现类的功能。
4.优缺点
（1）装饰者模式的优点和缺点如下所示：
- 优点
- 动态扩展：装饰者模式允许在运行时动态给对象添加新的功能，而无需修改其原始类或接口。通过装饰器的层层包装，可以灵活地组合各个功能模块，实现不同组合的功能扩展。
- 开闭原则：装饰者模式遵循开闭原则，允许向系统中添加新的装饰者，而无需修改现有代码。这使得系统更加灵活，易于扩展和维护。
- 单一职责原则：装饰者模式通过将功能细分到不同的装饰器中，使得每个装饰器只关注特定的责任或功能。这可以遵循单一职责原则，使类的设计更加清晰和可维护。
- 缺点
- 复杂性增加：使用装饰者模式会引入许多小的装饰器类，这可能增加类的数量和复杂性。当装饰者的层级过多时，代码可读性和理解难度会增加，维护也变得复杂。
- 注重细节：装饰者模式强调在对象之间细粒度的功能组合，这在某些情况下可能会添加不必要的复杂性。对于简单的场景，使用装饰者模式可能会显得过于繁琐。
- 初始对象需求：装饰者模式要求初始对象实现共同的接口或继承共同的抽象类，以便于装饰器的添加和替换。如果原始对象不符合这些要求，则在引入装饰者时需要进行额外的改造。
（2）总体而言，装饰者模式提供了一种灵活的方式来扩展对象的功能，符合开闭原则和单一职责原则。然而，它也可能引入复杂性并要求对代码进行更多的设计和精心安排。在实际应用中，需要根据具体场景来评估使用装饰者模式的利弊，权衡灵活性和复杂性之间的关系。
5.使用场景
（1）装饰者模式适用于以下场景：
- 动态添加功能：当需要在运行时动态地为对象添加额外的功能时，可以使用装饰者模式。它提供了一种灵活的方式来组合各个功能模块，而不需要修改原始对象的代码。
- 避免类爆炸：当类的数量可能会爆炸增长时，可以使用装饰者模式来避免创建大量的子类。通过装饰者模式，可以将各个功能划分到不同的装饰器类中，而不是创建多个子类来实现不同组合的功能。
- 单一职责原则：当一个类承担了多个责任或功能时，可以使用装饰者模式将每个功能划分到不同的装饰器类中。这样做可以遵循单一职责原则，使类的设计更加清晰和可维护。
- 可撤销的功能：当需要在运行时可以撤销已添加的功能时，装饰者模式提供了一种方便的方式。只需要移除相应的装饰器即可撤销已添加的功能，而不需要修改原始对象的代码。
- 继承和复合的替代方案：装饰者模式可以替代继承来扩展对象的功能。相比于继承，装饰者模式更加灵活，允许动态地组合各个功能模块，而不受类的继承关系的限制。
（2）总的来说，装饰者模式适用于需要动态地为对象添加功能或对对象的功能进行扩展的场景。它提供了一种灵活的方式来组合各个功能模块，保持接口的一致性，同时符合开闭原则和单一职责原则。常见的应用场景包括：日志记录、缓存、权限验证、事务管理等。
6.JDK 源码解析——BufferedWriter
（1）I/O 流中的包装类使用到了装饰者模式：BufferedInputStream，BufferedOutputStream，BufferedReader，BufferedWriter。
（2）现以 BufferedWriter 举例来说明，先看看如何使用 BufferedWriter：
import java.io.BufferedWriter;
import java.io.FileWriter;
public class Demo {
public static void main(String[] args) throws Exception{
//创建 BufferedWriter 对象
//创建 FileWriter 对象
FileWriter fw = new FileWriter("E:\\a.txt");
BufferedWriter bw = new BufferedWriter(fw);
//写数据
bw.write("hello Buffered");
bw.close();
}
}
使用起来感觉确实像是装饰者模式，接下来看它们的结构：
小结：BufferedWriter 使用装饰者模式对 Writer 子实现类进行了增强，添加了缓冲区，提高了写数据的效率。
7.装饰者模式和代理模式的比较
（1）装饰者模式和代理模式是两种常见的结构型设计模式，它们有一些相似之处，但也有一些区别。
- 相似之处：
- 装饰者模式和代理模式都使用了对象组合的方式来实现功能的扩展。
- 两者都可以在不修改原始对象的情况下对其进行包装，并在其上添加新的行为或功能。
- 区别：
- 装饰者模式强调对对象功能的动态扩展，它在不改变接口的前提下，通过包装和嵌套多个装饰器对象来实现功能的叠加。装饰者模式允许对对象的行为进行链式调用和组合，它的目的是增强对象的功能。
- 代理模式则是在不直接访问原始对象的情况下，通过代理对象对原始对象进行控制和访问。代理模式可以在访问对象时引入额外的控制层，用于控制对原始对象的访问并提供其他的辅助功能，如权限控制、延迟加载、缓存等。代理模式的目的是控制对象的访问。
（2）简而言之：
- 装饰者模式注重功能的动态扩展和组合，它通过装饰器对象将新的功能添加到原始对象上。
- 代理模式注重对对象的控制和访问，它通过代理对象控制对原始对象的访问，并可以提供额外的辅助功能。
相关知识点：
Java 设计模式——代理模式