根据枚举(enum)值执行代码的最优方案：消除switch分支重复方法调用

我们可以基于「每个Status对应一组固定顺序的执行动作链」的业务逻辑建模，完全消除重复调用代码，同时保证执行顺序不变，核心思路是把动作和状态直接绑定，统一执行逻辑。

方案1：枚举绑定方法引用（轻量场景首选） #

如果你的simulateA/simulateB/simulateC都是当前类的普通方法，直接用Java枚举绑定方法引用列表即可：

第一步：改造Status枚举 #

import java.util.List;
import java.util.function.Consumer;

public enum Status {
    // 每个状态按顺序绑定要执行的方法引用
    A(List.of(CurrentClass::simulateA)),
    B(List.of(CurrentClass::simulateA, CurrentClass::simulateB)),
    C(List.of(CurrentClass::simulateA, CurrentClass::simulateB, CurrentClass::simulateC));

    private final List<Consumer<String>> actionChain;

    Status(List<Consumer<String>> actionChain) {
        this.actionChain = actionChain;
    }

    public List<Consumer<String>> getActionChain() {
        return actionChain;
    }
}

注：把CurrentClass替换成你原来定义simulate方法的类名即可

第二步：简化simulate方法 #

public void simulate(String given, Status status) {
    status.getActionChain().forEach(action -> action.accept(given));
}

方案2：策略模式组合动作（复杂扩展场景首选） #

如果后续动作需要新增独立逻辑（比如参数校验、依赖注入、异常统一处理），可以把每个模拟动作抽象成独立的策略类，再和状态绑定：

第一步：定义动作公共接口 #

public interface SimulateAction {
    void execute(String given);
}

第二步：实现每个动作的独立类 #

// 对应原来的simulateA逻辑
public class SimulateAAction implements SimulateAction {
    @Override
    public void execute(String given) {
        // 原有simulateA的业务逻辑
    }
}

// 对应原来的simulateB逻辑
public class SimulateBAction implements SimulateAction {
    @Override
    public void execute(String given) {
        // 原有simulateB的业务逻辑
    }
}

// 同理实现SimulateCAction

第三步：枚举绑定动作实例列表 #

import java.util.List;

public enum Status {
    A(List.of(new SimulateAAction())),
    B(List.of(new SimulateAAction(), new SimulateBAction())),
    C(List.of(new SimulateAAction(), new SimulateBAction(), new SimulateCAction()));

    private final List<SimulateAction> actionChain;

    Status(List<SimulateAction> actionChain) {
        this.actionChain = actionChain;
    }

    // 直接封装执行逻辑，外层调用更简洁
    public void run(String given) {
        actionChain.forEach(action -> action.execute(given));
    }
}

第四步：简化simulate方法 #

public void simulate(String given, Status status) {
    status.run(given);
}

方案优势 #

• 完全保证方法调用顺序：动作链的顺序和原switch分支的执行顺序完全一致
• 无重复逻辑：每个模拟动作的实现只写一次，不同状态仅复用动作引用
• 符合开闭原则：后续新增Status只需要在枚举里定义对应的动作链，不需要修改simulate核心执行逻辑
• 可维护性强：状态和对应执行动作的绑定关系显式声明，不用翻switch分支就能明确每个状态的执行逻辑

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