Java不支持多继承时，多类型Handler层级结构的实现方案咨询

嘿，这个问题太典型了——Java确实不允许类的多继承，但我们有两种非常靠谱的方式来实现你想要的功能，完美适配你这种分输入、输出类型处理数据的场景。咱们一个个说：

从Java 8开始，接口支持默认方法，可以在接口里提供方法的具体实现。刚好可以把你原来的输入、输出类型Handler的特有方法实现，放到对应的接口中，然后让具体类继承基础抽象类的同时，实现这些接口，就能复用逻辑了。

重构后的代码大概是这样：

// 基础抽象类：保留通用方法，只声明需要具体类实现的method4
abstract class AbstractHandler {
    public void method1() { 
        // 所有子类通用的实现逻辑
    }
    public abstract void method4();
}

// 输入类型A的接口：用默认方法实现method2
public interface InputTypeA {
    default void method2() {
        // InputTypeA专属的method2实现
    }
}

// 输出类型B的接口：用默认方法实现method3
public interface OutputTypeB {
    default void method3() {
        // OutputTypeB专属的method3实现
    }
}

// 具体Handler：继承基础类+实现输入输出接口，只需要实现method4
public class ConcreteHandler1 extends AbstractHandler implements InputTypeA, OutputTypeB {
    @Override
    public void method4() {
        // ConcreteHandler1特有的method4实现
    }
}

这样一来，ConcreteHandler1自动拥有了AbstractHandler的method1、InputTypeA的method2、OutputTypeB的method3，只需要实现自己的method4就行，完全符合你的需求，也避开了多继承的限制。

如果你的输入、输出处理逻辑比较复杂，或者需要动态切换不同的输入输出实现，那用组合（委托）模式会更合适——简单来说，就是把输入、输出的处理逻辑封装成独立的类，让具体Handler持有这些类的实例，通过调用实例的方法来复用逻辑。

代码示例如下：

// 先定义输入、输出的接口
public interface InputHandler {
    void method2();
}

public interface OutputHandler {
    void method3();
}

// 输入类型A的具体实现类
public class InputTypeAHandlerImpl implements InputHandler {
    @Override
    public void method2() {
        // InputTypeA的method2实现
    }
}

// 输出类型B的具体实现类
public class OutputTypeBHandlerImpl implements OutputHandler {
    @Override
    public void method3() {
        // OutputTypeB的method3实现
    }
}

// 基础抽象类：还是保留通用方法和抽象的method4
abstract class AbstractHandler {
    public void method1() { 
        // 通用实现
    }
    public abstract void method4();
}

// 具体Handler：继承基础类，同时实现输入输出接口，通过委托复用逻辑
public class ConcreteHandler1 extends AbstractHandler implements InputHandler, OutputHandler {
    // 持有输入、输出处理的实例
    private InputHandler inputHandler;
    private OutputHandler outputHandler;

    public ConcreteHandler1() {
        // 初始化对应的输入输出实现
        this.inputHandler = new InputTypeAHandlerImpl();
        this.outputHandler = new OutputTypeBHandlerImpl();
    }

    @Override
    public void method2() {
        // 委托给inputHandler处理
        inputHandler.method2();
    }

    @Override
    public void method3() {
        // 委托给outputHandler处理
        outputHandler.method3();
    }

    @Override
    public void method4() {
        // 自己的特有实现
    }
}

这种方式的好处是灵活性极高——比如你想把ConcreteHandler1的输出类型换成OutputTypeA，只需要修改构造方法里的实例即可，不用修改类的继承结构，也符合面向对象里“组合优于继承”的设计原则。

两种方案怎么选？ #

• 如果你的输入/输出处理逻辑是无状态的、比较简单，方案一足够简洁，代码量少；
• 如果需要处理有状态的逻辑，或者未来可能要动态切换输入输出的实现，方案二更适合，扩展性更强。

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