装饰器模式

装饰器模式

定义

装饰模式是一种结构型设计模式，允许动态地向对象添加新功能，而不会影响其他对象。装饰模式通过使用一系列装饰类，将额外的行为或责任以层叠的方式附加到对象上。

核心概念

角组成

1. 抽象组件（Component） 定义对象可以动态添加行为的接口。
2. 具体组件（Concrete Component） 实现抽象组件接口的基本对象，可被装饰类增强功能。
3. 抽象装饰（Decorator） 持有一个抽象组件的引用，并定义一个与抽象组件一致的接口。
4. 具体装饰（Concrete Decorator） 扩展抽象装饰类，负责向组件添加额外功能。

装饰模式的类图

使用场景

1. 功能扩展：需要在运行时动态地添加、修改或移除对象的行为。
2. 避免继承膨胀：如果通过继承为对象添加功能会导致大量子类，装饰模式是更优的选择。
3. 遵守开放-封闭原则：装饰类可以独立扩展，而不需要修改已有的类。

装饰模式的优缺点

优点

1. 动态扩展功能：无需修改原始类，通过组合灵活添加功能。
2. 遵守单一职责原则：每个装饰类负责特定功能，职责清晰。
3. 避免类爆炸：减少子类数量，简化系统。

缺点

1. 对象数量增加：多层装饰可能导致对象管理复杂化。
2. 调试困难：由于装饰层叠的特性，可能难以跟踪功能的来源。

使用案例

案例 1：图形系统

• 描述：在绘图应用中，可以为基本形状动态添加边框、阴影、颜等功能。
• 实现：基本形状为组件，装饰器实现不同的图形效果。

案例 2：输入流

• 描述：在 Java 或 C# 中，输入流（如 FileStream）可以通过装饰器动态添加功能（如缓冲、加密）。
• 实现：基础流是组件，加密流、缓冲流是装饰器。

C++ 实现

#include <iostream>
#include <memory>
using namespace std;

// 抽象组件
class Component {
public:
    virtual void operation() ct = 0;
    virtual ~Component() = default;
};

// 具体组件
class ConcreteComponent : public Component {
public:
    void operation() ct override {
        cout << "ConcreteComponent operation" << endl;
    }
};

// 抽象装饰
class Decorator : public Component {
protected:
    shared_ptr<Component> component;

public:
    explicit Decorator(shared_ptr<Component> comp) : component(move(comp)) {}
    void operation() ct override {
        component->operation();
    }
};

// 具体装饰A
class ConcreteDecoratorA : public Decorator {
public:
    explicit ConcreteDecoratorA(shared_ptr<Component> comp) : Decorator(move(comp)) {}
    void operation() ct override {
        Decorator::operation();
        addedBehavior();
    }

    void addedBehavior() ct {
        cout << "ConcreteDecoratorA added behavior" << endl;
    }
};

// 具体装饰B
class ConcreteDecoratorB : public Decorator {
public:
    explicit ConcreteDecoratorB(shared_ptr<Component> comp) : Decorator(move(comp)) {}
    void operation() ct override {
        Decorator::operation();
        addedBehavior();
    }

    void addedBehavior() ct {
        cout << "ConcreteDecoratorB added behavior" << endl;
    }
};

// 客户端代码
int main() {
    shared_ptr<Component> component = make_shared<ConcreteComponent>();
    shared_ptr<Component> decoratorA = make_shared<ConcreteDecoratorA>(component);
    shared_ptr<Component> decoratorB = make_shared<ConcreteDecoratorB>(decoratorA);

    decoratorB->operation();

    return 0;
}

C# 实现

using System;

// 抽象组件
public abstract class Component {
    public abstract void Operation();
}

// 具体组件
public class ConcreteComponent : Component {
    public override void Operation() {
        Cole.WriteLine("ConcreteComponent operation");
    }
}

// 抽象装饰
public abstract class Decorator : Component {
    protected Component component;

    public Decorator(Component component) {
        thisponent = component;
    }

    public override void Operation() {
        component.Operation();
    }
}

// 具体装饰A
public class ConcreteDecoratorA : Decorator {
    public ConcreteDecoratorA(Component component) : base(component) { }

    public override void Operation() {
        base.Operation();
        AddedBehavior();
    }

    private void AddedBehavior() {
        Cole.WriteLine("ConcreteDecoratorA added behavior");
    }
}

// 具体装饰B
public class ConcreteDecoratorB : Decorator {
    public ConcreteDecoratorB(Component component) : base(component) { }

    public override void Operation() {
        base.Operation();
        AddedBehavior();
    }

    private void AddedBehavior() {
        Cole.WriteLine("ConcreteDecoratorB added behavior");
    }
}

// 客户端代码
class Program {
    static void Main() {
        Component component = new ConcreteComponent();
        Component decoratorA = new ConcreteDecoratorA(component);
        Component decoratorB = new ConcreteDecoratorB(decoratorA);

        decoratorB.Operation();
    }
}

知识点对比表

总结

1. 动态扩展功能：装饰模式适合在运行时灵活地扩展对象行为。
2. 避免类爆炸：通过装饰类组合，取代大量子类的设计。
3. 推荐场景：需要动态变化的系统功能，且遵守开放-封闭原则的设计要求。

欢迎关注、点赞、收藏！更多系列内容可以点击专栏目录订阅，感谢支持，再次祝大家祉猷并茂，顺遂无虞！

若将文章用作它处，请一定注明出处，商用请私信联系我！