1. 设计模式-装饰器模式

装饰器模式（Decorator Pattern）是一种结构型设计模式，它动态地给一个对象添加一些额外的职责，就增加功能来说，装饰器模式相比生成子类更为灵活。这种模式创建了一个装饰类，用来包装原有的类，并在保持原有类方法签名完整性的基础上，提供了额外的功能。

2. 抽象组件 (`Component`)

定义一个接口或抽象类，声明了所有装饰器和被装饰对象共有的操作。

public interface Component {
    void operation();
}

3. 具体组件 (`ConcreteComponent`)

实现了 Component 接口的实体类，即需要被装饰的基本对象。

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

4. 抽象装饰器 (`Decorator`)

继承自 Component，并包含一个对 Component 的引用，用于存储被装饰的对象。

public class Decorator implements Component {
    protected Component component;

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

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

5. 具体装饰器 (`ConcreteDecoratorA` 和 `ConcreteDecoratorB`)

具体装饰器类，负责给 Component 添加额外的行为。

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

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

    private void addedBehaviorA() {
        System.out.println("ConcreteDecoratorA Added Behavior");
    }
}

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

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

    private void addedBehaviorB() {
        System.out.println("ConcreteDecoratorB Added Behavior");
    }
}

6. 使用示例

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

        decoratorAB.operation();
    }
}

装饰器模式为对象提供了灵活的扩展机制，特别适合在不影响已有代码结构的基础上，为对象添加新的功能或行为。它强调了面向对象设计的“组合优于继承”的原则，但在使用时需要注意控制装饰器的层数，避免过度装饰导致的结构复杂化。装饰器模式是处理系统中职责变化较为频繁部分的一种优雅方式，但需权衡其带来的内存开销与系统复杂度的提升。

7. 优点

灵活性高：可以在运行时动态地给对象添加功能，无需修改原有对象的结构。
遵循开放封闭原则：对扩展开放（新增装饰器），对修改封闭（不改变组件接口和实现）。
简化对象的创建过程：通过组合而非继承来扩展功能，避免了类爆炸问题。

8. 缺点

装饰器使用不当可能造成对象结构复杂：过度装饰会导致对象层级过深，难以理解与维护。
装饰模式比直接使用继承更消耗内存：因为每个装饰对象都需要单独实例化，增加了对象的数量。