能否动态变更CommonAction的父类？多Action类代码复用方案咨询

嘿，这个问题挺典型的——Java是单继承静态语言，类的继承关系是编译期就确定死的，没法让CommonAction在运行时动态切换父类（一会儿继承HRAction，一会儿继承ManagerAction）。不过咱们完全可以用其他设计思路绕开这个限制，既保留两个Action原有的父类，又能完美复用通用代码！

下面给你几个实用的解决方案，按推荐优先级排序：

方案一：用「组合」代替「继承」（最推荐） #

这是面向对象设计里的经典原则：多用组合，少用继承。核心思路是把通用代码抽成一个独立的助手类，让两个Action类持有这个助手类的实例，而不是让它当父类。

示例代码：

// 抽离通用逻辑到助手类
public class CommonActionHelper {
    // 这里放原来想放到CommonAction里的通用方法
    public void commonValidate() {
        // 比如通用参数校验逻辑
        System.out.println("执行通用参数校验");
    }

    public String formatResult(Object data) {
        // 比如通用结果格式化逻辑
        return "统一格式：" + data.toString();
    }
}

// 保留原有继承关系，通过组合复用通用代码
public class Employee1Action extends HRAction {
    private final CommonActionHelper commonHelper = new CommonActionHelper();

    public void handleHRRequest() {
        // 调用通用方法
        commonHelper.commonValidate();
        // 执行HR专属逻辑
        super.hrSpecificMethod();
        String result = commonHelper.formatResult("HR处理完成");
        System.out.println(result);
    }
}

// 同理处理Manager的Action
public class Employee2Action extends ManagerAction {
    private final CommonActionHelper commonHelper = new CommonActionHelper();

    public void handleManagerRequest() {
        commonHelper.commonValidate();
        super.managerSpecificMethod();
        String result = commonHelper.formatResult("Manager处理完成");
        System.out.println(result);
    }
}

这个方案的好处：

• 完全保留了两个Action原有的父类继承关系
• 通用代码集中管理，修改时只需要改CommonActionHelper
• 灵活性更高，后续如果其他类也需要复用通用逻辑，直接组合这个助手类就行

方案二：用接口+默认方法（Java 8+适用） #

如果你的通用逻辑是一些独立的、不依赖父类状态的行为，可以定义一个接口，用Java 8的默认方法实现通用逻辑，然后让两个Action类同时实现这个接口。

示例代码：

// 定义通用行为的接口，用默认方法实现通用逻辑
public interface CommonAction {
    default void commonValidate() {
        System.out.println("执行通用参数校验");
    }

    default String formatResult(Object data) {
        return "统一格式：" + data.toString();
    }
}

// 同时继承原有父类+实现通用接口
public class Employee1Action extends HRAction implements CommonAction {
    public void handleHRRequest() {
        // 直接调用接口的默认方法
        commonValidate();
        super.hrSpecificMethod();
        String result = formatResult("HR处理完成");
        System.out.println(result);
    }
}

public class Employee2Action extends ManagerAction implements CommonAction {
    public void handleManagerRequest() {
        commonValidate();
        super.managerSpecificMethod();
        String result = formatResult("Manager处理完成");
        System.out.println(result);
    }
}

这个方案适合通用逻辑比较简单、不需要访问父类私有/保护成员的场景，代码更简洁，但灵活性不如组合。

方案三：策略模式（应对通用逻辑中有差异化的场景） #

如果你的通用逻辑里，有部分行为需要根据HRAction/ManagerAction的差异调整，可以用策略模式把差异化逻辑抽成独立的策略类，让通用助手类根据不同场景切换策略。

示例代码：

// 定义差异化行为的策略接口
public interface ActionStrategy {
    void executeSpecificLogic();
}

// HR专属策略
public class HRActionStrategy implements ActionStrategy {
    @Override
    public void executeSpecificLogic() {
        System.out.println("执行HR专属的前置逻辑");
    }
}

// Manager专属策略
public class ManagerActionStrategy implements ActionStrategy {
    @Override
    public void executeSpecificLogic() {
        System.out.println("执行Manager专属的前置逻辑");
    }
}

// 通用助手类，持有策略实例
public class CommonActionHelper {
    private final ActionStrategy strategy;

    public CommonActionHelper(ActionStrategy strategy) {
        this.strategy = strategy;
    }

    public void processRequest() {
        // 通用逻辑
        System.out.println("执行通用请求预处理");
        // 执行对应策略的差异化逻辑
        strategy.executeSpecificLogic();
        // 通用收尾逻辑
        System.out.println("执行通用请求收尾");
    }
}

// Employee1Action使用HR策略
public class Employee1Action extends HRAction {
    private final CommonActionHelper commonHelper = new CommonActionHelper(new HRActionStrategy());

    public void handleHRRequest() {
        commonHelper.processRequest();
        super.hrSpecificMethod();
    }
}

// Employee2Action使用Manager策略
public class Employee2Action extends ManagerAction {
    private final CommonActionHelper commonHelper = new CommonActionHelper(new ManagerActionStrategy());

    public void handleManagerRequest() {
        commonHelper.processRequest();
        super.managerSpecificMethod();
    }
}

这个方案适合通用逻辑和差异化逻辑混合的场景，能很好地分离通用和可变部分，后续新增类似Action时，只需要新增对应的策略类即可。

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