Java继承与泛型对比：Executor场景下的选型分析

场景需求 #

需要实现一套能接收输入、执行通用逻辑并返回输出的Executor组件，同时要编写服务来管理多个此类Executor，根据条件选择合适的实例执行并获取结果。

继承实现方案 #

// 基础输入输出类
class Input {
    String id;
}

class Output {
    long executionTime;
}

// 业务专属输入输出
class StringUpperInput extends Input {
    String stringToUpper;
}

class StringUpperOutput extends Output {
    String upperCaseString;
}

// 执行器接口
interface Executor {
    // 接收输入执行逻辑并返回输出
    Output execute(Input i);
}

// 业务执行器实现
class StringUpperExecutor implements Executor {
    @Override
    public Output execute(Input i) {
        String upper = ((StringUpperInput) i).stringToUpper.toUpperCase();
        StringUpperOutput output = new StringUpperOutput();
        output.upperCaseString = upper;
        // 设置executionTime等通用字段
        return output;
    }
}

泛型实现方案 #

// 通用输入输出包装类
class GenericInput<I> {
    String id;
    I inputObj;
}

class GenericOutput<O> {
    long executionTime;
    O outputObj;
}

// 业务专属参数类
class StringUpperInputParam {
    String stringToUpper;
}

class StringUpperOutputResult {
    String upperCaseString;
}

// 泛型执行器接口
interface ExecutorGeneric<I, O> {
    GenericOutput<O> execute(GenericInput<I> input);
}

// 业务泛型执行器实现
class StringUpperGenericExecutor implements ExecutorGeneric<StringUpperInputParam, StringUpperOutputResult> {

    @Override
    public GenericOutput<StringUpperOutputResult> execute(GenericInput<StringUpperInputParam> input) {
        GenericOutput<StringUpperOutputResult> resultWrapper = new GenericOutput<>();
        StringUpperOutputResult result = new StringUpperOutputResult();
        result.upperCaseString = input.inputObj.stringToUpper.toUpperCase();
        resultWrapper.outputObj = result;
        
        // 设置executionTime等通用字段
        return resultWrapper;
    }
}

方案对比与优缺点分析 #

继承方案 #

优势

• 结构贴合传统面向对象继承逻辑，通用字段（如Input.id、Output.executionTime）直接复用，代码直观易读
• 简单场景下代码量更少，快速上手成本低

不足

• 必须使用强制类型转换，编译期无法校验输入输出的类型匹配，运行时容易抛出ClassCastException
• 扩展能力弱：新增业务类型需要不断继承父类，易造成类层级臃肿，不符合单一职责原则
• 管理多个Executor时，只能统一用Executor接口，无法在编译期约束输入输出的对应关系，类型安全性差

泛型方案 #

优势

• 编译期类型安全：通过泛型参数<I,O>明确绑定输入输出类型，无需强制转换，彻底避免运行时类型错误
• 职责划分清晰：通用字段封装在包装类中，业务参数独立成类，代码结构更整洁
• 扩展性强：新增业务只需定义专属参数类，实现泛型接口即可，不会导致类层级膨胀
• 管理Executor时，可通过泛型约束更精准地管控不同类型的实例，类型匹配更可靠

不足

• 初期需要额外定义通用包装类，代码结构稍显繁琐
• 对于极简单的场景，泛型封装会增加少量理解成本

选型建议 #

• 如果业务场景简单，输入输出类型极少且无扩展预期，继承方案可以快速落地，实现成本更低
• 如果需要管理多类型Executor、追求类型安全，且业务有扩展需求，泛型方案是更合适的选择，它能让代码更健壮、易维护

内容的提问来源于stack exchange，提问作者Pepria