JavaFX多按钮场景切换问题：大量Switch-Case优化问询

Hey there! Let's fix that clunky switch-case mess in your JavaFX scene switching code. I totally get it—having a huge block of case statements makes the code hard to read and even harder to maintain when you add new scenes later. Here are a few solid refactoring approaches to clean this up:

The simplest fix is to use a Map to store the action corresponding to each button ID. This way, you can look up the action directly instead of iterating through case statements every time.

First, define the map (you can initialize it once when your app starts):

// Assuming button IDs are Strings; adjust the key type if you're using integers
private Map<String, Runnable> sceneSwitchActions = new HashMap<>();

// Initialize the map with your scene switching logic
private void initSceneSwitchActions(Stage stage) {
    sceneSwitchActions.put("homeBtn", () -> switchToHomeScene(stage));
    sceneSwitchActions.put("settingsBtn", () -> switchToSettingsScene(stage));
    sceneSwitchActions.put("profileBtn", () -> switchToProfileScene(stage));
    // Add more entries for each button/scene pair
}

// Helper methods for each scene switch (keeps logic separated)
private void switchToHomeScene(Stage stage) {
    // Load home scene logic here
    try {
        FXMLLoader loader = new FXMLLoader(getClass().getResource("home.fxml"));
        Scene homeScene = new Scene(loader.load());
        stage.setScene(homeScene);
    } catch (IOException e) {
        e.printStackTrace();
    }
}

// Repeat similar methods for other scenes...

Then update your handle method and button binding:

// Bind buttons (you can do this after initializing the map)
for (Button button : buttonsArray) {
    button.setOnAction(e -> handleSceneSwitch(button.getId()));
}

// Your simplified handle method
private void handleSceneSwitch(String buttonId) {
    Runnable action = sceneSwitchActions.get(buttonId);
    if (action != null) {
        action.run();
    } else {
        // Handle unknown button ID (optional)
        System.err.println("No action mapped for button ID: " + buttonId);
    }
}

For better organization, wrap all scene switching logic into a single SceneNavigator class. This keeps your UI code clean and centralizes all navigation logic.

public class SceneNavigator {
    private final Stage primaryStage;
    // Optional: Cache loaded scenes to avoid reloading them every time
    private Map<String, Scene> sceneCache = new HashMap<>();

    public SceneNavigator(Stage primaryStage) {
        this.primaryStage = primaryStage;
    }

    public void goToHome() {
        Scene homeScene = getOrLoadScene("home.fxml");
        primaryStage.setScene(homeScene);
    }

    public void goToSettings() {
        Scene settingsScene = getOrLoadScene("settings.fxml");
        primaryStage.setScene(settingsScene);
    }

    // Helper to load or retrieve cached scenes
    private Scene getOrLoadScene(String fxmlPath) {
        if (sceneCache.containsKey(fxmlPath)) {
            return sceneCache.get(fxmlPath);
        }
        try {
            FXMLLoader loader = new FXMLLoader(getClass().getResource(fxmlPath));
            Scene scene = new Scene(loader.load());
            sceneCache.put(fxmlPath, scene);
            return scene;
        } catch (IOException e) {
            e.printStackTrace();
            throw new RuntimeException("Failed to load scene: " + fxmlPath);
        }
    }
}

Then in your main code, map buttons to navigator methods:

SceneNavigator navigator = new SceneNavigator(primaryStage);
Map<String, Runnable> actionMap = new HashMap<>();
actionMap.put("homeBtn", navigator::goToHome);
actionMap.put("settingsBtn", navigator::goToSettings);

buttonsArray.forEach(button -> {
    button.setOnAction(e -> actionMap.get(button.getId()).run());
});

If your button actions involve more than just switching scenes (e.g., validation, data saving), the Command Pattern is a great fit. It encapsulates each action into its own class, making your code highly modular.

First, define a command interface:

public interface SceneCommand {
    void execute();
}

Then create concrete command classes for each action:

public class HomeSceneCommand implements SceneCommand {
    private final SceneNavigator navigator;

    public HomeSceneCommand(SceneNavigator navigator) {
        this.navigator = navigator;
    }

    @Override
    public void execute() {
        // Add any pre-switch logic here (e.g., save current state)
        navigator.goToHome();
    }
}

// Similar classes for other scenes...

Bind commands to buttons:

SceneNavigator navigator = new SceneNavigator(primaryStage);
Map<String, SceneCommand> commandMap = new HashMap<>();
commandMap.put("homeBtn", new HomeSceneCommand(navigator));
commandMap.put("settingsBtn", new SettingsSceneCommand(navigator));

buttonsArray.forEach(button -> {
    button.setOnAction(e -> commandMap.get(button.getId()).execute());
});

All these approaches follow the Open/Closed Principle—when you add a new scene, you just add a new entry to the map or a new command class, no need to modify existing switch-case code. This makes your code far easier to maintain and extend.

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