设计模式使用场景实现示例（结构型模式——装饰器模式）

在一个被高山和浓密森林包围的古老王国中，有一位技艺高超的工匠名叫李奥。李奥擅长制作各种各样的物品，从精致的首饰到坚固的盔甲。然而，他最引以为傲的创造是一把能够根据持有者的需要变换形态的神奇剑。

这把剑被命名为“千面剑”。起初，它只是一把普通的铁剑，但李奥利用了一种古老的技术——我们现代人可能会称之为“装饰器模式”。通过这种技术，李奥能够为剑加上不同的魔法元素作为“装饰”，使剑的功能随时可以改变，而不需要重新制造。

有一天，国王的使者来到李奥的工坊，请求一把能够在即将到来的大战中为国王带来胜利的特殊武器。李奥决定将“千面剑”交给国王。

在战争中，这把剑展示了其真正的力量。当国王需要对抗敌人的重甲骑士时，剑变成了一把锋利无匹的长剑；当面对快速移动的敌人时，它又能变成轻巧的短剑。在战斗的不同阶段，剑的“装饰”根据需要进行更换，每次都完美地适应了战场的状况。

装饰器模式（Decorator Pattern）

装饰器模式（Decorator Pattern）是一种结构型设计模式，它允许你动态地为对象添加新的行为，而无需改变其代码。装饰器模式通过创建一个装饰类来包装原始类，从而增强或改变其功能。

适用场景

1. 需要扩展一个类的功能：

   • 需要为一个类添加一些额外的职责，而不希望修改原始类的代码。

2. 动态添加功能：

   • 希望通过组合多个装饰器动态地添加功能。

3. 希望实现功能的按需组合：

   • 通过多个装饰器可以组合出不同的功能组合，避免创建大量的子类。

实现示例（Java）

以下是一个简单的装饰器模式的实现示例，展示如何动态地为一个对象添加新功能。

1. 定义组件接口

public interface Component {
    void operation();
}

2. 定义具体组件类

public class ConcreteComponent implements Component {
    @Override
    public void operation() {
        System.out.println("ConcreteComponent operation");
    }
}

3. 定义装饰器抽象类

public abstract class Decorator implements Component {
    protected Component component;

    public Decorator(Component component) {
        this.component = component;
    }

    @Override
    public void operation() {
        component.operation();
    }
}

4. 定义具体装饰器类

public class ConcreteDecoratorA extends Decorator {
    public ConcreteDecoratorA(Component component) {
        super(component);
    }

    @Override
    public void operation() {
        super.operation();
        addedBehavior();
    }

    private void addedBehavior() {
        System.out.println("ConcreteDecoratorA added behavior");
    }
}

public class ConcreteDecoratorB extends Decorator {
    public ConcreteDecoratorB(Component component) {
        super(component);
    }

    @Override
    public void operation() {
        super.operation();
        addedBehavior();
    }

    private void addedBehavior() {
        System.out.println("ConcreteDecoratorB added behavior");
    }
}

5. 客户端代码

public class Client {
    public static void main(String[] args) {
        Component component = new ConcreteComponent();
        Component decoratorA = new ConcreteDecoratorA(component);
        Component decoratorB = new ConcreteDecoratorB(decoratorA);

        decoratorB.operation();
    }
}

注释说明

1. 组件接口：

   • Component 接口定义了一个方法 operation，这是所有组件和装饰器都需要实现的方法。

2. 具体组件类：

   • ConcreteComponent 是一个具体的组件类，实现了 Component 接口的方法。

3. 装饰器抽象类：

   • Decorator 是一个抽象类，实现了 Component 接口，并持有一个 Component 对象。它的 operation 方法调用了被装饰对象的 operation 方法。

4. 具体装饰器类：

   • ConcreteDecoratorA 和 ConcreteDecoratorB 是具体的装饰器类，它们继承自 Decorator 并添加了新的行为。

5. 客户端代码：

   • Client 类通过组合多个装饰器来增强 ConcreteComponent 的功能。decoratorB 包装了 decoratorA，而 decoratorA 包装了 component，最终调用 operation 方法时，会依次调用各个装饰器和具体组件的方法。

类图

Client
  |
  v
Component <---- Decorator <---- ConcreteDecoratorA
  ^                                |
  |                                v
ConcreteComponent          ConcreteDecoratorB

总结

装饰器模式通过创建装饰器类来包装原始类，使得你可以动态地添加或改变对象的行为。它适用于需要扩展类的功能且不希望修改原始类代码的场景，同时通过组合多个装饰器可以实现功能的按需组合，避免创建大量的子类。