Java方法中如何基于step参数控制执行流程，避免冗余if判断？

问题描述 #

我有如下process方法，需要根据传入的step参数决定执行到哪一步后返回。请问有没有无需编写多个if语句的实现方式？允许重新设计方法。
（补充说明：用Switch-Case能实现反向逻辑，也就是执行指定step及后续所有步骤，比如step=3时执行3、4、5等步骤）

原代码：

public void process(Document document, int step) {
    this.processHeader(document);
    
    if(step==1) {
      return;
    }

    this.processContent(document);
    
    if(step==2) {
      return;
    }

    this.processFooter(document);
    
    if(step==3) {
      return;
    }

    // and so on
}

解决方案 #

1. 用列表存储步骤动作（推荐，扩展性强） #

把每个步骤的处理逻辑封装成Consumer<Document>，按执行顺序存入列表，之后只需循环执行到指定step对应的索引即可。新增步骤时直接往列表里追加，不用修改判断逻辑。

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

public class Processor {
    // 按执行顺序存储所有步骤操作
    private final List<Consumer<Document>> stepActions = List.of(
        this::processHeader,
        this::processContent,
        this::processFooter
        // 后续步骤直接追加到这里
    );

    public void process(Document document, int step) {
        // step=1对应执行第1个步骤（索引0），循环到step-1的位置
        for (int i = 0; i < step && i < stepActions.size(); i++) {
            stepActions.get(i).accept(document);
        }
    }

    private void processHeader(Document document) {
        // 原处理逻辑
    }

    private void processContent(Document document) {
        // 原处理逻辑
    }

    private void processFooter(Document document) {
        // 原处理逻辑
    }
}

2. 用枚举定义步骤（逻辑更清晰） #

把每个步骤定义成枚举实例，每个实例绑定对应的处理方法，利用枚举的天然顺序控制执行流程，适合需要给步骤附加额外信息（比如名称、描述）的场景。

import java.util.function.Consumer;

public class Processor {
    private enum ProcessStep {
        HEADER(Processor::processHeader),
        CONTENT(Processor::processContent),
        FOOTER(Processor::processFooter);
        // 后续步骤直接新增枚举项即可

        private final Consumer<Document> action;

        ProcessStep(Consumer<Document> action) {
            this.action = action;
        }

        public void execute(Processor processor, Document document) {
            action.accept(document);
        }
    }

    public void process(Document document, int step) {
        ProcessStep[] allSteps = ProcessStep.values();
        for (int i = 0; i < step && i < allSteps.length; i++) {
            allSteps[i].execute(this, document);
        }
    }

    private void processHeader(Document document) {
        // 原处理逻辑
    }

    private void processContent(Document document) {
        // 原处理逻辑
    }

    private void processFooter(Document document) {
        // 原处理逻辑
    }
}

3. 反向逻辑的Switch-Case优化 #

如果需要实现“执行指定step及后续所有步骤”，可以利用Switch-Case的fall-through特性（传统写法不写break），不用重复编写调用逻辑：

public void processReverse(Document document, int step) {
    // 传统Switch实现fall-through，执行当前step及后续所有步骤
    switch (step) {
        case 1:
            processHeader(document);
        case 2:
            processContent(document);
        case 3:
            processFooter(document);
            // 后续步骤继续往下追加
        default:
            break;
    }
}

注：Java 12+的箭头式Switch默认不支持fall-through，要实现这个逻辑得用上面的传统Switch写法。

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