面试题：Java泛型在复杂设计模式组合中的深度应用

Question

考虑一个综合了桥接模式、策略模式和装饰器模式的复杂系统，其中需要处理多种不同类型的数据对象，并且每种数据对象可能有不同的处理策略和装饰方式。请详细描述如何运用Java泛型来统一管理和优化这三种设计模式的交互，以提高系统的扩展性、灵活性和类型安全性。要求给出详细的系统架构设计图、核心代码片段，并深入分析泛型在各个模式结合点上的作用和实现细节。

Answer 1

系统架构设计图

1. 总体架构：
   • DataObject 层次结构：定义一个基础的 DataObject 抽象类，不同类型的数据对象继承自该类。例如 SpecificDataObject1、SpecificDataObject2 等。
   • Bridge 模式：
     • 定义一个抽象的 DataProcessor 接口，作为桥接的抽象部分。具体的处理器实现类如 ConcreteDataProcessor1、ConcreteDataProcessor2 实现该接口。
     • 在 DataObject 抽象类中持有一个 DataProcessor 实例，通过构造函数或 setter 方法注入。
   • Strategy 模式：
     • 定义一个 DataHandlingStrategy 接口，不同的数据处理策略类如 Strategy1、Strategy2 实现该接口。
     • 在 DataProcessor 实现类中，持有一个 DataHandlingStrategy 实例，并在处理数据的方法中调用该策略的方法。
   • Decorator 模式：
     • 定义一个 DataObjectDecorator 抽象类，继承自 DataObject，持有一个 DataObject 实例。
     • 具体的装饰器类如 ConcreteDecorator1、ConcreteDecorator2 继承自 DataObjectDecorator，并在构造函数中接收被装饰的 DataObject 实例，在实现的方法中调用被装饰对象的方法并添加额外的行为。
   • 泛型的引入：
     • 在 DataProcessor 接口、DataHandlingStrategy 接口以及 DataObjectDecorator 抽象类中引入泛型，使得它们能够处理不同类型的数据对象，同时保证类型安全。

@startuml
package "Data Objects" {
    abstract class DataObject
    class SpecificDataObject1 extends DataObject
    class SpecificDataObject2 extends DataObject
}

package "Bridge Pattern" {
    interface DataProcessor<T extends DataObject>
    class ConcreteDataProcessor1 implements DataProcessor<SpecificDataObject1>
    class ConcreteDataProcessor2 implements DataProcessor<SpecificDataObject2>
}

package "Strategy Pattern" {
    interface DataHandlingStrategy<T extends DataObject>
    class Strategy1 implements DataHandlingStrategy<SpecificDataObject1>
    class Strategy2 implements DataHandlingStrategy<SpecificDataObject2>
}

package "Decorator Pattern" {
    abstract class DataObjectDecorator<T extends DataObject> extends DataObject {
        T dataObject
    }
    class ConcreteDecorator1<T extends DataObject> extends DataObjectDecorator<T>
    class ConcreteDecorator2<T extends DataObject> extends DataObjectDecorator<T>
}

DataObject "1" -- "1" DataProcessor : uses
DataProcessor "1" -- "1" DataHandlingStrategy : uses
DataObjectDecorator "1" -- "1" DataObject : contains
@enduml

核心代码片段

1. DataObject 抽象类：

public abstract class DataObject {
    // 通用的数据对象属性和方法
}

2. 具体数据对象类：

public class SpecificDataObject1 extends DataObject {
    // 特定数据对象1的属性和方法
}

public class SpecificDataObject2 extends DataObject {
    // 特定数据对象2的属性和方法
}

3. Bridge 模式相关代码：

public interface DataProcessor<T extends DataObject> {
    void process(T dataObject);
}

public class ConcreteDataProcessor1 implements DataProcessor<SpecificDataObject1> {
    private DataHandlingStrategy<SpecificDataObject1> strategy;

    public ConcreteDataProcessor1(DataHandlingStrategy<SpecificDataObject1> strategy) {
        this.strategy = strategy;
    }

    @Override
    public void process(SpecificDataObject1 dataObject) {
        strategy.handle(dataObject);
    }
}

public class ConcreteDataProcessor2 implements DataProcessor<SpecificDataObject2> {
    private DataHandlingStrategy<SpecificDataObject2> strategy;

    public ConcreteDataProcessor2(DataHandlingStrategy<SpecificDataObject2> strategy) {
        this.strategy = strategy;
    }

    @Override
    public void process(SpecificDataObject2 dataObject) {
        strategy.handle(dataObject);
    }
}

4. Strategy 模式相关代码：

public interface DataHandlingStrategy<T extends DataObject> {
    void handle(T dataObject);
}

public class Strategy1 implements DataHandlingStrategy<SpecificDataObject1> {
    @Override
    public void handle(SpecificDataObject1 dataObject) {
        // 具体的处理逻辑1
    }
}

public class Strategy2 implements DataHandlingStrategy<SpecificDataObject2> {
    @Override
    public void handle(SpecificDataObject2 dataObject) {
        // 具体的处理逻辑2
    }
}

5. Decorator 模式相关代码：

public abstract class DataObjectDecorator<T extends DataObject> extends DataObject {
    protected T dataObject;

    public DataObjectDecorator(T dataObject) {
        this.dataObject = dataObject;
    }
}

public class ConcreteDecorator1<T extends DataObject> extends DataObjectDecorator<T> {
    public ConcreteDecorator1(T dataObject) {
        super(dataObject);
    }

    @Override
    public void someMethod() {
        // 调用被装饰对象的方法并添加额外行为
        dataObject.someMethod();
        // 额外行为
    }
}

public class ConcreteDecorator2<T extends DataObject> extends DataObjectDecorator<T> {
    public ConcreteDecorator2(T dataObject) {
        super(dataObject);
    }

    @Override
    public void someMethod() {
        // 调用被装饰对象的方法并添加额外行为
        dataObject.someMethod();
        // 额外行为
    }
}

泛型在各个模式结合点上的作用和实现细节

1. 在 Bridge 模式中：
   • 作用：通过在 DataProcessor 接口中使用泛型 <T extends DataObject>，使得不同的 DataProcessor 实现类能够针对特定类型的数据对象进行处理，提高了类型安全性。同时，泛型使得桥接模式更加灵活，能够轻松添加新的数据对象类型和对应的处理器。
   • 实现细节：DataProcessor 的具体实现类如 ConcreteDataProcessor1、ConcreteDataProcessor2 明确指定了泛型类型，如 ConcreteDataProcessor1 implements DataProcessor<SpecificDataObject1>，这样在 process 方法中接收的参数类型就是明确的 SpecificDataObject1，避免了类型转换错误。
2. 在 Strategy 模式中：
   • 作用：DataHandlingStrategy 接口使用泛型 <T extends DataObject>，使得不同的处理策略能够与特定类型的数据对象绑定，增强了策略模式的类型安全性和灵活性。不同的策略可以根据数据对象的类型进行定制化处理。
   • 实现细节：Strategy1、Strategy2 等策略类实现 DataHandlingStrategy 接口时，明确指定泛型类型，如 Strategy1 implements DataHandlingStrategy<SpecificDataObject1>，在 handle 方法中处理特定类型的数据对象，确保处理逻辑与数据对象类型匹配。
3. 在 Decorator 模式中：
   • 作用：DataObjectDecorator 抽象类使用泛型 <T extends DataObject>，使得装饰器能够处理不同类型的数据对象，同时保证类型安全。装饰器可以根据数据对象的类型进行定制化装饰。
   • 实现细节：ConcreteDecorator1、ConcreteDecorator2 等具体装饰器类继承 DataObjectDecorator 时，明确指定泛型类型，如 ConcreteDecorator1<T extends DataObject>，在构造函数中接收特定类型的数据对象实例，如 public ConcreteDecorator1(T dataObject)，在实现的方法中能够安全地调用被装饰对象的方法并添加额外行为。

通过使用 Java 泛型，这三种设计模式能够更紧密、更安全地结合在一起，提高系统的扩展性、灵活性和类型安全性。