Java如何根据用户输入跳转回指定checkpoint 避免多层嵌套循环

Java本身没有原生goto语句，但有两种常用的实现可以满足你的需求，完全不需要多层嵌套循环：

方案1：带标签的continue（适合中小规模程序） #

利用Java支持的带标签跳转语法，直接在你要返回的checkpoint位置外层套一个无限循环，需要跳转时直接调用带标签的continue即可：

import java.util.Scanner;

class RandomStuff {
    public static void main (String[]args){
        Scanner keyboard = new Scanner(System.in);
        String again;

        // 定义标签，对应你要返回的checkpoint位置
        checkpoint: while(true) {
            System.out.println("Press 1 to continue, press 2 to cancel ");
            int number = keyboard.nextInt();

            switch(number){
                case 1:
                    System.out.println("user chose to continue");
                    break;
                case 2:
                    System.out.println("user chose to cancel");
                    System.out.println("start again? (yes/no)");
                    again = keyboard.next();
                    if("yes".equals(again)){
                        // 直接跳转回checkpoint位置
                        continue checkpoint;
                    } else {
                        System.exit(0);
                    }
                    break;
            }

            // 后续其他问题的逻辑，任意位置需要跳转都可以调用continue checkpoint
            // 比如第二个问题示例
            System.out.println("问题2：输入1继续，2退出");
            int num2 = keyboard.nextInt();
            if(num2 == 2) {
                System.out.println("start again? (yes/no)");
                again = keyboard.next();
                if("yes".equals(again)) continue checkpoint;
                else System.exit(0);
            }

            // 所有问题走完后正常结束循环
            break;
        }

        keyboard.close();
    }
}

这种方案的优点是改动极小，写法简单，符合你现有代码的逻辑。

方案2：状态机模式（适合多问题、需要长期维护的项目） #

如果你的问题数量很多，后续还有扩展需求，更推荐用状态机实现，完全避免嵌套逻辑：

1. 先定义所有程序状态的枚举：

enum ProgramState {
    CHECKPOINT, // 对应你要返回的检查点
    QUESTION_1,
    QUESTION_2,
    QUESTION_3,
    EXIT
}

2. 主循环只负责根据当前状态执行对应逻辑，跳转只需修改当前状态值：

import java.util.Scanner;

class RandomStuff {
    public static void main (String[]args){
        Scanner keyboard = new Scanner(System.in);
        ProgramState currentState = ProgramState.CHECKPOINT;
        String again;

        while(currentState != ProgramState.EXIT) {
            switch (currentState) {
                case CHECKPOINT:
                    // 检查点的初始化逻辑
                    System.out.println("程序已重置到检查点");
                    currentState = ProgramState.QUESTION_1;
                    break;
                case QUESTION_1:
                    System.out.println("问题1：按1继续，按2取消");
                    int num1 = keyboard.nextInt();
                    if(num1 == 1) {
                        currentState = ProgramState.QUESTION_2;
                    } else {
                        System.out.println("是否重新开始？(yes/no)");
                        again = keyboard.next();
                        currentState = "yes".equals(again) ? ProgramState.CHECKPOINT : ProgramState.EXIT;
                    }
                    break;
                case QUESTION_2:
                    // 第二个问题的逻辑，需要跳转直接修改currentState为CHECKPOINT即可
                    System.out.println("问题2：按1继续，按2取消");
                    int num2 = keyboard.nextInt();
                    if(num2 == 1) {
                        // 所有问题走完就设置为EXIT
                        currentState = ProgramState.EXIT;
                    } else {
                        System.out.println("是否重新开始？(yes/no)");
                        again = keyboard.next();
                        currentState = "yes".equals(again) ? ProgramState.CHECKPOINT : ProgramState.EXIT;
                    }
                    break;
            }
        }

        keyboard.close();
    }
}

这种方案的优点是逻辑完全解耦，新增问题只需要加枚举值和对应分支即可，完全不会出现嵌套层级越来越深的问题。

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