如何消除Java程序中大量的if-else分支结构？

针对你当前代码中大量if-else判断命令的问题，最有效的优化方式是采用命令模式+哈希映射的组合，将每个命令的逻辑封装为独立类，通过字符串直接映射到对应执行逻辑，彻底消除硬编码的分支判断。

步骤1：定义统一命令接口 #

先创建一个顶层Command接口，规范所有命令的执行逻辑和帮助信息输出：

import java.util.Scanner;

public interface Command {
    // 执行命令逻辑
    void execute(Scanner scanner);
    // 获取命令的帮助提示（用于输出可选子命令）
    String getHelp();
}

步骤2：实现具体命令类 #

把原来每个分支的逻辑拆成独立的命令类，包括顶层命令和子命令：

示例1：带命令组的顶层命令（如StringCommand） #

对于包含子命令的命令组，内部维护子命令的映射表：

import java.util.HashMap;
import java.util.Map;
import java.util.Scanner;

public class StringCommand implements Command {
    private final Map<String, Command> subCommands = new HashMap<>();
    private final Logger logger = new Logger();

    public StringCommand() {
        // 注册子命令
        subCommands.put("substring", new SubstringCommand());
        subCommands.put("append", new AppendCommand());
        subCommands.put("tolowercase", new ToLowerCaseCommand());
        subCommands.put("touppercase", new ToUpperCaseCommand());
        subCommands.put("replace", new ReplaceCommand());
    }

    @Override
    public void execute(Scanner scanner) {
        System.out.println(getHelp());
        System.out.print("Enter method: ");
        String subCommand = scanner.nextLine().toLowerCase();
        logger.LogSubMethod(subCommand);
        
        // 查找并执行子命令
        Command command = subCommands.get(subCommand);
        if (command != null) {
            command.execute(scanner);
        } else {
            System.out.println("Invalid sub command!");
        }
    }

    @Override
    public String getHelp() {
        return "Available methods for string:\n" +
                "Substring\n" +
                "Append\n" +
                "toLowerCase\n" +
                "toUpperCase\n" +
                "Replace";
    }
}

// 子命令实现示例
class SubstringCommand implements Command {
    @Override
    public void execute(Scanner scanner) {
        new StringProcessing().substringString();
    }

    @Override
    public String getHelp() {
        return "Extract substring from input string";
    }
}

class AppendCommand implements Command {
    @Override
    public void execute(Scanner scanner) {
        new StringProcessing().appendString();
    }

    @Override
    public String getHelp() {
        return "Append string to input";
    }
}

示例2：简单顶层命令（如TimeCommand） #

对于没有子命令的简单命令，直接实现逻辑：

import java.util.Date;
import java.util.Scanner;

public class TimeCommand implements Command {
    @Override
    public void execute(Scanner scanner) {
        Date date = new Date();
        System.out.println("Current time: " + date);
        System.out.println("--------------------------------");
        new MainMenu().Menu();
    }

    @Override
    public String getHelp() {
        return "Show current system time";
    }
}

示例3：CalcCommand（类似StringCommand实现子命令映射） #

import java.util.HashMap;
import java.util.Map;
import java.util.Scanner;

public class CalcCommand implements Command {
    private final Map<String, Command> subCommands = new HashMap<>();
    private final Logger logger = new Logger();

    public CalcCommand() {
        subCommands.put("sum", new SumCommand());
        subCommands.put("minus", new MinusCommand());
        subCommands.put("multiplication", new MultiplicationCommand());
        // 其他计算器子命令依次注册...
    }

    @Override
    public void execute(Scanner scanner) {
        System.out.println(getHelp());
        System.out.print("Enter method: ");
        String subCommand = scanner.nextLine().toLowerCase();
        logger.LogSubMethod(subCommand);
        
        Command command = subCommands.get(subCommand);
        if (command != null) {
            command.execute(scanner);
        } else {
            System.out.println("Invalid calculator command!");
        }
    }

    @Override
    public String getHelp() {
        return "Available methods for calculator:\n" +
                "Sum\n" +
                "minus\n" +
                "multiplication\n" +
                "division\n" +
                // 其他计算器命令列表...
                "tanh";
    }
}

class SumCommand implements Command {
    @Override
    public void execute(Scanner scanner) {
        new Calculator().sumComplete();
    }

    @Override
    public String getHelp() {
        return "Calculate sum of numbers";
    }
}

步骤3：构建全局命令注册表 #

在程序初始化时，创建一个全局的命令映射表，把所有顶层命令注册进去：

import java.util.HashMap;
import java.util.Map;

public class CommandRegistry {
    private static final Map<String, Command> COMMANDS = new HashMap<>();

    static {
        // 注册所有顶层命令
        COMMANDS.put("string", new StringCommand());
        COMMANDS.put("calc", new CalcCommand());
        COMMANDS.put("info", new InfoCommand());
        COMMANDS.put("time", new TimeCommand());
        COMMANDS.put("ip", new IpCommand());
        COMMANDS.put("check", new CheckCommand());
        COMMANDS.put("log", new LogCommand());
    }

    public static Command getCommand(String commandName) {
        return COMMANDS.get(commandName.toLowerCase());
    }
}

步骤4：重构主逻辑代码 #

原来的大量if-else分支可以彻底替换为简洁的映射查找：

import java.util.Scanner;

// 原主逻辑代码重构后
public class MainMenu {
    private Scanner scanner;
    private Logger logger;
    private String nameProperty; // 假设该属性已初始化

    public void Menu() {
        scanner = new Scanner(System.in);
        logger = new Logger();
        
        System.out.print("Welcome " + nameProperty + " to the program!\nInput your command: ");
        String inputCommand = scanner.nextLine().toLowerCase();
        logger.commandLoggerWriter(inputCommand);

        // 通过注册表获取命令并执行
        Command command = CommandRegistry.getCommand(inputCommand);
        if (command != null) {
            command.execute(scanner);
        } else {
            System.out.println("Invalid command! Please try again.");
            Menu();
        }
    }
}

额外优化点 #

1. 命令模糊匹配：如果需要保留原代码中contains的模糊匹配逻辑，可以修改CommandRegistry.getCommand方法，遍历映射表查找包含关键词的命令（但建议尽量使用精确匹配，减少歧义）。
2. 抽象公共逻辑：可以创建抽象基类AbstractCommand，把日志记录、菜单跳转等公共逻辑放到基类中，避免重复代码。
3. 动态注册：如果需要支持动态添加命令，可以把CommandRegistry的映射表改为可修改的，提供注册方法。

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