Java设计模式（十）装饰器模式

一、概述

装饰器模式是一种结构型设计模式，它允许向现有对象动态地添加新的行为，同时又不改变其结构。装饰器模式通过将对象包装在一个装饰器类中，来扩展其功能。

二、代码示例

以下是一个示例代码，说明装饰器模式的使用：

//1.抽象组件接口
public interface Component {
    void operation();
}
//2.装饰器抽象类
public abstract class Decorator implements Component {
    protected Component component;

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

    @Override
    public void operation() {
        component.operation();
    }
}
//3.具体组件类
public class ConcreteComponent implements Component {
    @Override
    public void operation() {
        System.out.println("我是基础组件");
    }
}
//4.具体装饰器类A
public class ConcreteDecoratorA extends Decorator {
    public ConcreteDecoratorA(Component component) {
        super(component);
    }

    @Override
    public void operation() {
        super.operation();
        System.out.println("装饰器A进行装饰...");
    }
}
//5.具体装饰器类B
public class ConcreteDecoratorB extends Decorator {
    public ConcreteDecoratorB(Component component) {
        super(component);
    }

    @Override
    public void operation() {
        super.operation();
        System.out.println("装饰器B进行装饰...");
    }
}
//6.测试类
public class Test {
    public static void main(String[] args) {
        //基础组件
        System.out.println("基础组件:");
        Component component = new ConcreteComponent();
        component.operation();
        System.out.println("---------------");
        //装饰器A装饰
        System.out.println("装饰器A装饰:");
        Component decoratedComponentA = new ConcreteDecoratorA(component);
        decoratedComponentA.operation();
        System.out.println("---------------");
        //装饰器B装饰
        System.out.println("装饰器B装饰:");
        Component decoratedComponentB = new ConcreteDecoratorB(component);
        decoratedComponentB.operation();
        System.out.println("---------------");
        //装饰器A和B都装饰
        System.out.println("装饰器A和B都装饰:");
        Component decoratedComponentAB = new ConcreteDecoratorB(new ConcreteDecoratorA(component));
        decoratedComponentAB.operation();
        System.out.println("---------------");
    }
}

在上述代码中，Component 是抽象组件接口，定义了组件的基本操作方法 operation()。ConcreteComponent 是具体的组件类，实现了 Component 接口，并提供了具体的实现。

Decorator 是装饰器抽象类，它实现了 Component 接口，并包含一个指向被装饰对象的引用。在 operation() 方法中，它会调用被装饰对象的操作方法。

ConcreteDecoratorA 和 ConcreteDecoratorB 是具体的装饰器类，它们继承自 Decorator 并扩展了功能。在 operation() 方法中，它们会先调用被装饰对象的操作方法，然后添加自己的额外操作。

在测试代码中，我们首先创建了一个具体的组件对象 ConcreteComponent，并调用其 operation() 方法。然后，我们通过创建不同的装饰器对象来对组件进行装饰，如 ConcreteDecoratorA 和 ConcreteDecoratorB。最后，我们还可以使用多个装饰器来进行嵌套装饰。

通过装饰器模式，我们可以动态地向现有对象添加新的行为，而不需要修改其原始实现。这样可以实现更好的可扩展性和灵活性，同时遵循开闭原则。装饰器模式使得对象的功能可以在运行时动态地被扩展，而无需对现有代码进行修改。这种模式也避免了使用继承带来的静态扩展限制，同时提供了一种比继承更灵活的方式来组合和扩展对象的行为。

装饰器模式常用于以下情况：

• 当需要在不修改现有对象的情况下，动态地添加功能或修改行为时。
• 当存在多个不同组合方式的对象，需要灵活地组合和操作这些对象时。

通过使用装饰器模式，我们可以通过组合装饰器对象来实现不同的功能组合，而不需要创建大量的子类。这种方式避免了类爆炸的问题，同时提供了更好的代码可读性和可维护性。

需要注意的是，装饰器模式会增加代码的复杂性，因为需要创建多个装饰器类来实现不同的功能组合。此外，装饰器模式可能会导致对象的层次结构变得复杂，因为每个具体装饰器都需要持有一个被装饰对象的引用。

然而，装饰器模式在许多情况下是一个非常有用的设计模式，特别是当需要灵活地扩展对象的功能时。它提供了一种优雅而灵活的方式来实现功能的动态组合，以满足不同的需求。

三、java中的装饰器模式

在Java中，输入输出流使用了装饰器模式（Decorator Pattern）。装饰器模式允许在不修改原始对象的情况下，通过将其包装在装饰器类中来动态地扩展其功能。

以下是一个示例代码，说明在Java中使用装饰器模式来处理输入输出流：

public class FileIOExample {
    public static void main(String[] args) {
        try {
            // 创建基本的文件输出流
            OutputStream fileOutputStream = new FileOutputStream("output.txt");

            // 使用装饰器模式包装文件输出流，实现缓冲功能
            BufferedOutputStream bufferedOutputStream = new BufferedOutputStream(fileOutputStream);

            // 使用装饰器模式包装缓冲输出流，实现数据编码功能
            DataOutputStream dataOutputStream = new DataOutputStream(bufferedOutputStream);

            // 写入数据
            dataOutputStream.writeUTF("Hello, World!");

            // 关闭流
            dataOutputStream.close();

            // 创建基本的文件输入流
            InputStream fileInputStream = new FileInputStream("output.txt");

            // 使用装饰器模式包装文件输入流，实现缓冲功能
            BufferedInputStream bufferedInputStream = new BufferedInputStream(fileInputStream);

            // 使用装饰器模式包装缓冲输入流，实现数据解码功能
            DataInputStream dataInputStream = new DataInputStream(bufferedInputStream);

            // 读取数据
            String stringValue = dataInputStream.readUTF();

            // 输出读取的数据
            System.out.println("String value: " + stringValue);

            // 关闭流
            dataInputStream.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

在上述代码中，我们使用了多个装饰器类来扩展基本的文件输入输出流的功能。首先，我们创建了一个基本的文件输出流 FileOutputStream，然后使用装饰器类 BufferedOutputStream 包装它，实现了缓冲功能。接着，我们再次使用装饰器类 DataOutputStream 包装缓冲输出流，实现了数据编码功能。

类似地，我们创建了一个基本的文件输入流 FileInputStream，然后使用装饰器类 BufferedInputStream 包装它，实现了缓冲功能。再次使用装饰器类 DataInputStream 包装缓冲输入流，实现了数据解码功能。

通过使用装饰器模式，我们可以按需动态地扩展输入输出流的功能，而不需要修改原始的输入输出流类。这样可以实现对输入输出流的灵活处理，提高代码的可扩展性和可维护性。