设计模式 9 装饰器模式

设计模式 9

创建型模式（5）：工厂方法模式、抽象工厂模式、单例模式、建造者模式、原型模式
结构型模式（7）：适配器模式、桥接模式、组合模式、装饰者模式、外观模式、享元模式、代理模式
行为型模式（11）：责任链模式、命令模式、解释器模式、迭代器模式、中介者模式、备忘录模式、观察者模式、状态模式、策略模式、模板方法模式、访问者模式

文章目录

[设计模式 9](#设计模式 9)
- [装饰器模式（Decorator Pattern）](#装饰器模式（Decorator Pattern）)
- - [1 定义](#1 定义)
  - [2 结构](#2 结构)
  - [3 示例代码](#3 示例代码)
  - [4 特点](#4 特点)
  - [5 适用场景](#5 适用场景)
  - [6 与其他模式对比](#6 与其他模式对比)

装饰器模式（Decorator Pattern）

1 定义

装饰器模式通过创建一个装饰器类，它实现了与被装饰对象相同的接口，从而可以在运行时动态地添加新功能。这种模式提供了一种灵活的替代方案来扩展对象的功能，避免了使用子类来扩展功能的需要。

2 结构

装饰器模式的结构包含以下角色：

组件（Component）: 定义一个接口，描述可以动态添加的功能。
具体组件（Concrete Component） : 实现 Component 接口的具体对象，表示要装饰的对象。
装饰器（Decorator） : 维护一个对 Component 对象的引用，定义与 Component 接口相同的接口，并可以在运行时扩展功能。
具体装饰器（Concrete Decorator） : 扩展 Decorator，实现具体的附加功能。

UML 类图

scss 复制代码

+-------------------+
|     Component     |
+-------------------+
| + Operation()     |
+-------------------+
        ^
        |
+-------------------+          +---------------------------+
| ConcreteComponent | <------- |    Decorator              |
+-------------------+          +---------------------------+
| + Operation()     |          | - component: Component    |
+-------------------+          | + Operation()             |
                               +---------------------------+
                                          ^
                                          |
                               +------------------------+
                               |  ConcreteDecorator     |
                               +------------------------+
                               | + Operation()          |
                               | + AdditionalBehavior() |
                               +------------------------+

3 示例代码

以下是一个实现装饰器模式的简单示例。在这个示例中，我们有一个饮料的系统，可以为饮料添加不同的配料（装饰）。

组件接口

csharp 复制代码

// 组件接口
public abstract class Beverage
{
    public abstract string GetDescription();
    public abstract double Cost();
}

具体组件类

csharp 复制代码

// 具体组件：咖啡
public class Coffee : Beverage
{
    public override string GetDescription()
    {
        return "Coffee";
    }

    public override double Cost()
    {
        return 2.00; // 基本咖啡的价格
    }
}

装饰器类

csharp 复制代码

// 装饰器类
public abstract class CondimentDecorator : Beverage
{
    protected Beverage _beverage;

    public CondimentDecorator(Beverage beverage)
    {
        _beverage = beverage;
    }
}

具体装饰器类

csharp 复制代码

// 具体装饰器：牛奶
public class MilkDecorator : CondimentDecorator
{
    public MilkDecorator(Beverage beverage) : base(beverage)
    {
    }

    public override string GetDescription()
    {
        return _beverage.GetDescription() + ", Milk";
    }

    public override double Cost()
    {
        return _beverage.Cost() + 0.50; // 添加牛奶的价格
    }
}

// 具体装饰器：巧克力
public class ChocolateDecorator : CondimentDecorator
{
    public ChocolateDecorator(Beverage beverage) : base(beverage)
    {
    }

    public override string GetDescription()
    {
        return _beverage.GetDescription() + ", Chocolate";
    }

    public override double Cost()
    {
        return _beverage.Cost() + 0.70; // 添加巧克力的价格
    }
}

客户端代码

csharp 复制代码

class Program
{
    static void Main(string[] args)
    {
        // 创建基本的咖啡
        Beverage beverage = new Coffee();

        // 添加配料
        beverage = new MilkDecorator(beverage);
        beverage = new ChocolateDecorator(beverage);

        // 显示描述和总费用
        Console.WriteLine($"{beverage.GetDescription()} costs {beverage.Cost():C}");
    }
}

在这个示例中：

Beverage 是组件接口，定义了饮料的基本功能。
Coffee 是具体组件，表示基础饮料（咖啡）。
CondimentDecorator 是装饰器类，它包含了对 Beverage 对象的引用，并实现了 Beverage 接口。
MilkDecorator 和 ChocolateDecorator 是具体装饰器，分别添加牛奶和巧克力的功能。

4 特点

优点:
- 灵活性: 可以动态添加和扩展对象的功能，而不需要创建大量的子类。
- 符合开闭原则: 可以通过添加新的装饰器类来扩展功能，而无需修改已有的类。
- 避免类的膨胀: 通过组合多个装饰器，可以避免创建过多的子类，从而减少类的数量。
缺点:
- 复杂性: 装饰器模式可能会增加系统的复杂性，尤其是当装饰器层次过多时。
- 调试困难: 由于装饰器的嵌套，调试代码时可能会变得复杂。

5 适用场景

需要动态扩展功能: 当你需要在运行时动态地给对象添加功能时，装饰器模式是一个理想的选择。
避免类的膨胀: 当类的扩展导致创建大量子类时，装饰器模式可以帮助你减少类的数量。
需要组合多个功能: 当你需要组合多个功能或行为时，装饰器模式能够轻松实现。

6 与其他模式对比

与组合模式的区别: 装饰器模式用于在不修改对象结构的情况下动态添加功能，而组合模式用于表示部分-整体的层次结构。
与代理模式的区别: 代理模式用于控制对对象的访问，而装饰器模式用于在不改变对象的接口的情况下动态添加功能。

装饰器模式提供了一种灵活的方式来扩展对象的功能，使得开发者可以在不影响已有代码的情况下，轻松地添加新的行为或属性。