【设计模式】用Java实现装饰模式

一.装饰模式介绍与使用场景

装饰模式（Decorator Pattern）是一种结构型设计模式，它允许在不改变现有对象结构的情况下，动态地将责任附加到对象上。装饰模式通过将对象包装在装饰器对象中，形成一条装饰链，每个装饰器对象都可以在被装饰对象的行为前后加上自己的行为。

装饰模式的核心思想是通过组合而不是继承来扩展对象的功能。它遵循开放-关闭原则，即对扩展开放，对修改关闭，使得我们可以在不修改现有代码的情况下，灵活地添加新的功能。

应用场景：

1. 需要在不改变现有对象结构的情况下，动态地为对象添加额外的功能。装饰模式通过组合而不是继承来实现功能的扩展，使得可以在运行时动态地添加、删除或修改对象的行为。

2. 需要对对象的功能进行多层次的包装和组合。装饰模式可以形成一条装饰链，每个装饰器可以独立地对被装饰对象进行包装，从而实现多个装饰器的叠加效果，灵活地组合功能。

3. 需要动态地为对象添加或移除功能。由于装饰模式是基于对象组合的，因此可以在运行时动态地添加或移除装饰器对象，实现对对象功能的动态调整。

4. 需要对一些特定对象或对象集合进行特殊处理，而不影响其他对象。装饰模式允许针对特定对象或对象集合创建特定的装饰器，对它们进行个性化的功能扩展，而不会影响其他对象。

装饰模式在许多应用中都有广泛的应用，例如：

• Java I/O流中的输入流和输出流的装饰器类（如BufferedInputStream和BufferedOutputStream）。
• 图形界面中的组件装饰，如对按钮添加边框、背景色等装饰效果。
• 日志记录器中的功能扩展，如在日志中添加时间戳、记录日志级别等功能。

总之，装饰模式适用于需要动态地为对象添加额外功能、实现多层次包装和组合、动态调整对象功能以及对特定对象进行特殊处理的场景。它提供了一种灵活、可扩展的方式来扩展对象的功能，同时遵循开放-关闭原则，使得系统的设计更加灵活和可维护。

二.装饰模式实现

下面是一个使用Java实现装饰模式的简单示例：

首先，定义一个抽象基础组件 Component，它声明了一个操作方法：

interface Component {
    void operation();
}

然后，创建具体的基础组件类 ConcreteComponent，它实现了抽象组件接口：

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

接下来，定义装饰器抽象类 Decorator，它也实现了抽象组件接口，并维持一个指向抽象组件的引用：

abstract class Decorator implements Component {
    protected Component component;

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

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

然后，创建具体的装饰器类 ConcreteDecorator，它继承自装饰器抽象类，并在装饰方法中添加额外的功能：

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

    public void operation() {
        // 在原有功能前后添加额外的功能
        System.out.println("Before operation in ConcreteDecorator.");
        super.operation();
        System.out.println("After operation in ConcreteDecorator.");
    }
}

最后，我们可以在客户端中使用这些类来创建和使用装饰对象：

public class Client {
    public static void main(String[] args) {
        // 创建基础组件对象
        Component component = new ConcreteComponent();

        // 使用装饰器包装基础组件对象
        Component decoratedComponent = new ConcreteDecorator(component);

        // 调用装饰后的操作方法
        decoratedComponent.operation();
    }
}

输出结果为：

Before operation in ConcreteDecorator.
Performing operation in ConcreteComponent.
After operation in ConcreteDecorator.

通过装饰模式，我们可以在不改变基础组件类的情况下，动态地为对象添加额外的功能。装饰器类和基础组件类之间使用组合关系，形成一条装饰链，每个装饰器都可以在调用基础组件的操作前后添加自己的行为。这样，我们可以灵活地扩展对象的功能，而无需修改现有代码。

下面再举一个例子，在实际项目中模拟咖啡店的咖啡订单系统。

假设我们有一个基础咖啡类 Coffee，它实现了咖啡接口：

interface Coffee {
    String getDescription();
    double getCost();
}

然后，创建具体的咖啡类 Espresso 和 Cappuccino，它们实现了咖啡接口并提供具体的描述和价格：

class Espresso implements Coffee {
    public String getDescription() {
        return "Espresso";
    }

    public double getCost() {
        return 2.0;
    }
}

class Cappuccino implements Coffee {
    public String getDescription() {
        return "Cappuccino";
    }

    public double getCost() {
        return 3.5;
    }
}

接下来，定义装饰器抽象类 CoffeeDecorator，它也实现了咖啡接口，并维持一个指向咖啡对象的引用：

abstract class CoffeeDecorator implements Coffee {
    protected Coffee coffee;

    public CoffeeDecorator(Coffee coffee) {
        this.coffee = coffee;
    }

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

    public double getCost() {
        return coffee.getCost();
    }
}

然后，创建具体的装饰器类 MilkDecorator 和 SugarDecorator，它们继承自装饰器抽象类，并在装饰方法中添加额外的功能：

class MilkDecorator extends CoffeeDecorator {
    public MilkDecorator(Coffee coffee) {
        super(coffee);
    }

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

    public double getCost() {
        return super.getCost() + 0.5;
    }
}

class SugarDecorator extends CoffeeDecorator {
    public SugarDecorator(Coffee coffee) {
        super(coffee);
    }

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

    public double getCost() {
        return super.getCost() + 0.2;
    }
}

最后，我们可以在客户端中使用这些类来创建和使用装饰对象：

public class Client {
    public static void main(String[] args) {
        // 创建基础咖啡对象
        Coffee espresso = new Espresso();
        Coffee cappuccino = new Cappuccino();

        // 使用装饰器包装咖啡对象
        Coffee milkEspresso = new MilkDecorator(espresso);
        Coffee sugarCappuccino = new SugarDecorator(cappuccino);

        // 输出咖啡描述和价格
        System.out.println(milkEspresso.getDescription() + " - $" + milkEspresso.getCost());
        System.out.println(sugarCappuccino.getDescription() + " - $" + sugarCappuccino.getCost());
    }
}

输出结果为：

Espresso, Milk - $2.5
Cappuccino, Sugar - $3.7

通过装饰模式，我们可以在不修改基础咖啡类的情况下，动态地为咖啡对象添加额外的功能，如添加牛奶和糖等。装饰器类和咖啡类之间使用组合关系，形成一条装饰链，每个装饰器都可以在调用咖啡对象的方法前后添加自己的行为。这样，我们可以根据客户的需求灵活地组合和定制咖啡，而不需要创建大量的子类。