如何实现可互相跳转的Java菜单并避免栈溢出与初始化问题？

问题背景 #

需要实现支持跨菜单跳转、互相引用（如菜单A可跳菜单B，B也可跳A）、动态添加选项的菜单系统，同时避免递归栈溢出。此前初始化菜单时因循环引用出现null问题，已自行修复，需评估实现合理性并获取优化建议。

当前实现代码 #

Menus.java #

public class Menus {
    public static Menu mainMenu = new Menu("Main Menu");
    public static Menu homeMenu = new Menu("Home Menu");
    public static Menu BMenu = new Menu("B Menu");

    public static void initMenus() {
        mainMenu.addOptions(
                new MenuOption(
                        "bmenu",
                        BMenu
                ),
                new MenuOption(
                        "exit",
                        mainMenu,
                        CLI::stop
                )
        );
        BMenu.addOptions(
                new MenuOption(
                        "main",
                        mainMenu
                ),
                new MenuOption(
                        "exit",
                        BMenu,
                        CLI::stop
                )
        );
    }
}

MenuOption.java #

public class MenuOption {
    private final String name;
    private final Runnable[] actions;
    private final Menu nextMenu;
    public MenuOption(String name, Menu nextMenu, Runnable... actions) {
        this.name = name;
        this.actions = actions;
        this.nextMenu = nextMenu;
    }
    public MenuOption(String name, Menu nextMenu) {
        this.name = name;
        this.actions = new Runnable[0];
        this.nextMenu = nextMenu;
    }
    public void run() {
        for (Runnable r : actions) {
            r.run();
        }
    }
    public void run(int delay) {
        for (Runnable r : actions) {
            r.run();
            try {
                Thread.sleep(delay);
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
                return;
            }
        }
    }

    public String getName() {
        return name;
    }

    public Menu getNextMenu() {
        return nextMenu;
    }
}

Menu.java #

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

public class Menu {
    private final String title;
    private final List<MenuOption> options;
    public Menu(String title, List<MenuOption> options) {
        this.title = title;
        this.options = options;
    }
    public Menu(String title, MenuOption... options) {
        this.title = title;
        this.options = new ArrayList<>(Arrays.asList(options));
    }

    public String getTitle() {
        return title;
    }

    public List<MenuOption> getOptions() {
        return options;
    }
    public Menu select(int index) {
        if (index > 0 && index <= options.size()) {
            options.get(index-1).run();
            return options.get(index-1).getNextMenu();
        }
        return this;
    }
    public void addOption(MenuOption option) {
        options.add(option);
    }
    public void addOptions(MenuOption... options) {
        for (MenuOption option : options) {
            addOption(option);
        }
    }
}

CLI.java #

import java.util.Arrays;
import java.util.Scanner;

public class CLI {
    private static Menu currentState = Menus.mainMenu;
    private static volatile boolean running = true;
    public static void run() {
        Scanner scanner = new Scanner(System.in);
        Menus.initMenus();
        while (running) {
            clearAndDisplay();
            currentState = currentState.select(scanner.nextInt());
        }
    }
    public static String generateMenu(String Title, String... options ) {
        StringBuilder menu = new StringBuilder();
        menu.append(Title).append("\n");
        for (int option = 1; option <= options.length; option++) {
            menu.append(option).append(". ").append(options[option-1]).append("\n");
        }
        return menu.toString();
    }

    public static String generateMenu(Menu state) {
        return generateMenu(state.getTitle(),
                state.getOptions().stream()
                        .map(MenuOption::getName)
                        .toArray(String[]::new)
        );
    }

    public static void clear() {
        System.out.print("\033[2J");
        System.out.print("\033[1;1H");
        System.out.flush();
    }
    public static void clearAndDisplay() {
        clear();
        System.out.print(generateMenu(currentState));
    }
    public static void stop() {
        running = false;
    }
}

问题排查与优化建议 #

现有实现合理性评估 #

• 核心逻辑可行：用迭代循环（CLI中的while循环）处理菜单跳转，而非递归，从根本上避免了栈溢出风险，这一点处理到位。
• 循环引用解决方案有效：通过先初始化空Menu对象，再在initMenus方法中延迟绑定选项的方式，解决了初始化时的null问题，是处理循环依赖的常规有效手段。

具体优化点 #

1. 解耦静态成员依赖
   当前Menus类用静态字段存储所有菜单，导致实例全局可见，不利于扩展和测试。建议改用单例模式或依赖注入管理菜单实例，降低耦合度。
2. 增强动态选项的线程安全性
   现有addOption方法直接操作普通List，多线程场景下动态添加选项会有并发风险。建议给optionsList加锁，或改用CopyOnWriteArrayList等线程安全集合。
3. 完善输入校验
   CLI中scanner.nextInt()未处理非整数输入，会抛出InputMismatchException导致程序崩溃。建议添加异常捕获逻辑，提示用户输入有效数字。
4. 优化菜单跳转的懒加载能力
   若需支持动态生成的菜单，可将MenuOption的nextMenu从直接引用改为Supplier<Menu>，实现懒加载，更灵活处理复杂依赖场景。
5. 规范代码命名
   类名BMenu不符合Java驼峰命名规范，应改为Bmenu或更具语义的名称（如SecondaryMenu）；generateMenu方法的参数Title应改为小写开头title。
6. 简化退出逻辑
   当前退出选项的nextMenu设为当前菜单，逻辑冗余。可将退出选项的nextMenu设为null，在CLI循环中判断，若返回null则直接终止循环，逻辑更清晰。

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