装饰者模式

3.1. 结构组成¶

装饰者模式主要由以下四个角色组成：

1. Component（组件）：定义一个对象接口，可以给这些对象动态地添加职责。

2. ConcreteComponent（具体组件）：定义了一个具体的对象，也可以给这个对象添加一些额外的职责。

3. Decorator（装饰类）：持有一个组件（Component）对象的引用，并定义一个与抽象组件接口一致的接口。

4. ConcreteDecorator（具体装饰类）：实现了装饰类的具体功能，给组件添加额外的职责。

角色关系：

• Decorator 包含一个 Component 对象的引用，并实现了 Component 接口。

• ConcreteDecorator 继承自 Decorator，并实现了具体的装饰功能。

• ConcreteComponent 实现了 Component 接口，表示被装饰的对象。

3.2. UML类图¶

以下是装饰者模式的简化UML类图：

+---------------------+
|      Component      |
+---------------------+
| + operation(): void |
+---------------------+
           ^
           |
+---------------------+       +-----------------------+
| ConcreteComponent   |       |     Decorator         |
+---------------------+       +-----------------------+
| + operation(): void |       | - component: Component|
+---------------------+       +-----------------------+
           ^                            ^
           |                            |
+-------------------------+       +-------------------------+
| ConcreteDecoratorA      |       | ConcreteDecoratorB      |
+-------------------------+       +-------------------------+
| + operation(): void     |       | + operation(): void     |
| + addedBehavior(): void |       | + addedBehavior(): void |
+-------------------------+       +-------------------------+

说明：

• Component 是一个接口或抽象类，定义了核心功能的接口。

• ConcreteComponent 实现了 Component，是被装饰的原始对象。

• Decorator 持有一个 Component 的引用，并实现了 Component 接口。

• ConcreteDecoratorA 和 ConcreteDecoratorB 继承自 Decorator，添加了各自的功能。

4.1. Java 实现示例¶

以下是一个使用装饰者模式实现咖啡订单系统的示例，其中Coffee是组件接口，SimpleCoffee是具体组件，MilkDecorator和SugarDecorator是具体装饰者。

// Component
public interface Coffee {
    double cost();
    String getDescription();
}

// ConcreteComponent
public class SimpleCoffee implements Coffee {
    @Override
    public double cost() {
        return 2.0;
    }

    @Override
    public String getDescription() {
        return "Simple Coffee";
    }
}

// Decorator
public abstract class CoffeeDecorator implements Coffee {
    protected Coffee decoratedCoffee;

    public CoffeeDecorator(Coffee c) {
        this.decoratedCoffee = c;
    }

    public double cost() {
        return decoratedCoffee.cost();
    }

    public String getDescription() {
        return decoratedCoffee.getDescription();
    }
}

// ConcreteDecoratorA
public class MilkDecorator extends CoffeeDecorator {
    public MilkDecorator(Coffee c) {
        super(c);
    }

    @Override
    public double cost() {
        return super.cost() + 0.5;
    }

    @Override
    public String getDescription() {
        return super.getDescription() + ", Milk";
    }
}

// ConcreteDecoratorB
public class SugarDecorator extends CoffeeDecorator {
    public SugarDecorator(Coffee c) {
        super(c);
    }

    @Override
    public double cost() {
        return super.cost() + 0.2;
    }

    @Override
    public String getDescription() {
        return super.getDescription() + ", Sugar";
    }
}

// 客户端代码
public class DecoratorPatternDemo {
    public static void main(String[] args) {
        Coffee coffee = new SimpleCoffee();
        System.out.println(coffee.getDescription() + " $" + coffee.cost());

        Coffee milkCoffee = new MilkDecorator(new SimpleCoffee());
        System.out.println(milkCoffee.getDescription() + " $" + milkCoffee.cost());

        Coffee sugarMilkCoffee = new SugarDecorator(new MilkDecorator(new SimpleCoffee()));
        System.out.println(sugarMilkCoffee.getDescription() + " $" + sugarMilkCoffee.cost());
    }
}

输出：

Simple Coffee $2.0
Simple Coffee, Milk $2.5
Simple Coffee, Milk, Sugar $2.7

4.2. Python 实现示例¶

以下是使用装饰者模式实现咖啡订单系统的Python示例。

from abc import ABC, abstractmethod

# Component
class Coffee(ABC):
    @abstractmethod
    def cost(self) -> float:
        pass

    @abstractmethod
    def get_description(self) -> str:
        pass

# ConcreteComponent
class SimpleCoffee(Coffee):
    def cost(self) -> float:
        return 2.0

    def get_description(self) -> str:
        return "Simple Coffee"

# Decorator
class CoffeeDecorator(Coffee):
    def __init__(self, coffee: Coffee):
        self.decorated_coffee = coffee

    def cost(self) -> float:
        return self.decorated_coffee.cost()

    def get_description(self) -> str:
        return self.decorated_coffee.get_description()

# ConcreteDecoratorA
class MilkDecorator(CoffeeDecorator):
    def cost(self) -> float:
        return super().cost() + 0.5

    def get_description(self) -> str:
        return super().get_description() + ", Milk"

# ConcreteDecoratorB
class SugarDecorator(CoffeeDecorator):
    def cost(self) -> float:
        return super().cost() + 0.2

    def get_description(self) -> str:
        return super().get_description() + ", Sugar"

# 客户端代码
if __name__ == "__main__":
    coffee = SimpleCoffee()
    print(f"{coffee.get_description()} ${coffee.cost()}")  # 输出: Simple Coffee $2.0

    milk_coffee = MilkDecorator(SimpleCoffee())
    print(f"{milk_coffee.get_description()} ${milk_coffee.cost()}")  # 输出: Simple Coffee, Milk $2.5

    sugar_milk_coffee = SugarDecorator(MilkDecorator(SimpleCoffee()))
    print(f"{sugar_milk_coffee.get_description()} ${sugar_milk_coffee.cost()}")  # 输出: Simple Coffee, Milk, Sugar $2.7

输出：

Simple Coffee $2.0
Simple Coffee, Milk $2.5
Simple Coffee, Milk, Sugar $2.7

6.1. 优点¶

1. 灵活性高：可以在运行时动态地为对象添加新的功能，无需修改原有类。

2. 遵循开放/关闭原则：对扩展开放，对修改关闭。通过添加新的装饰者类来扩展功能，而不需要修改已有的代码。

3. 避免类爆炸：通过组合多个装饰者来实现多种功能组合，避免了通过继承产生大量子类的问题。

4. 单一职责原则：每个装饰者负责添加一种具体的功能，职责单一，代码更易维护。

5. 透明性：装饰者与被装饰者实现相同的接口，客户端无需感知对象是否被装饰。

6.2. 缺点¶

1. 设计复杂度增加：引入了多个装饰者类和组合关系，可能使系统的类结构变得复杂。

2. 调试困难：由于装饰者是动态组合的，调试过程中可能难以追踪对象的实际功能组合。

3. 依赖具体装饰者：如果需要特定的装饰者功能，客户端可能需要了解和依赖具体的装饰者类，降低系统的封装性。

4. 性能开销：每个装饰者都会增加对象的包装层数，可能带来一定的性能开销，尤其是在装饰层数较多时。

7.1. 图形用户界面（GUI）组件¶

在GUI框架中，组件（如按钮、文本框）可以通过装饰者模式动态地添加滚动条、边框、阴影等功能。例如，Java的Swing库中的JScrollPane就是一个装饰者类，它为其他组件添加了滚动功能。

7.2. 输入/输出流¶

在Java中，I/O流的装饰者模式实现使得可以通过装饰者类动态地添加缓冲、过滤、压缩等功能。例如，BufferedInputStream和DataInputStream都是装饰者类，它们为基础的InputStream添加了缓冲和数据解析功能。

7.3. 日志系统¶

在日志记录系统中，可以通过装饰者模式为日志记录器添加不同的输出目标（如控制台、文件、网络）或日志级别（如INFO、DEBUG、ERROR）。这样，客户端可以灵活地组合需要的日志功能，而无需修改原有的日志记录器类。

7.4. 文本处理¶

在文本编辑器中，可以通过装饰者模式为文本对象添加不同的格式，如加粗、斜体、下划线、颜色等。每种格式通过一个装饰者类来实现，客户端可以根据需要动态地为文本添加或移除格式。

8.1. 装饰者模式 vs. 适配器模式¶

• 装饰者模式用于动态地为对象添加职责，增强对象的功能，强调的是功能的扩展。

• 适配器模式用于接口转换，使得不兼容的接口能够协同工作，强调的是接口的兼容性。

关键区别：

• 目的不同：装饰者模式是为了增加功能，适配器模式是为了兼容接口。

• 结构不同：装饰者模式通常是递归的，可以有多个装饰者层次；适配器模式通常是单层的。

8.2. 装饰者模式 vs. 组合模式¶

• 装饰者模式用于为对象动态添加职责，强调的是功能的扩展。

• 组合模式用于构建部分-整体的层次结构，强调的是对象的组织结构。

关键区别：

• 目的不同：装饰者模式是为了增加功能，组合模式是为了组织对象的层次结构。

• 结构不同：装饰者模式通常是通过装饰者类来包装单个对象；组合模式是通过树形结构来组织多个对象。

8.3. 装饰者模式 vs. 代理模式¶

• 装饰者模式用于动态地为对象添加职责，增强对象的功能。

• 代理模式用于控制对对象的访问，提供一个替代对象来管理对实际对象的访问。

关键区别：

• 目的不同：装饰者模式是为了增加功能，代理模式是为了控制访问。

• 结构不同：装饰者模式允许多个装饰者叠加，代理模式通常是单一的代理类。

8.4. 装饰者模式 vs. 策略模式¶

• 装饰者模式用于动态地为对象添加职责，增强对象的功能。

• 策略模式用于定义一系列算法，并使它们可以相互替换，封装算法的变化。

关键区别：

• 目的不同：装饰者模式是为了增加功能，策略模式是为了替换算法。

• 结构不同：装饰者模式是通过装饰者类包装对象，策略模式是通过策略接口定义算法并由具体策略类实现。