RPN计算器代码调试求助：switch语句无法正常工作

核心问题分析 #

1. Scanner未初始化：内部循环里的Scanner scanner仅声明未实例化，直接调用方法会触发空指针异常。
2. switch语句缺少判断表达式：switch()括号内为空，没有传入要匹配的输入值。
3. 输入变量类型不匹配：用Object存储输入字符串，无法和字符串类型的case分支匹配，应改为String类型。
4. default分支无处理逻辑：未对非法输入做提示。
5. 静态栈导致实例冲突：类中stack被声明为static，多个计算器实例会共享同一个栈，破坏数据独立性。

修正后的完整代码 #

import java.util.Scanner;
import java.util.Stack;

public class RPNCalculator {
    private Stack<Integer> stack; // 改为非static成员，保证实例独立性

    public RPNCalculator() {
        stack = new Stack<>(); // 创建栈
    }

    public static void main(String[] args) {
        String expression, again;
        int result;

        Scanner keyboard = new Scanner(System.in);

        do {
            RPNCalculator evaluator = new RPNCalculator();
            System.out.println("Enter a valid post-fix expression one token " +
                    "at a time with a space between each token (e.g. 5 4 + 3 2 1 - + *)");
            System.out.println("Each token must be an integer or an operator (+,-,*,/)");
            System.out.println();
            System.out.println("Enter 'q' to quit, 'h' for help.");

            expression = keyboard.nextLine();

            // 处理退出命令
            if (expression.equalsIgnoreCase("q")) {
                System.out.println("Exiting program");
                break;
            }
            // 处理帮助命令
            if (expression.equalsIgnoreCase("h") || expression.equals("?")) {
                printHelp();
                continue;
            }

            result = evaluator.evaluate(expression);
            System.out.println();
            System.out.println("That expression equals " + result);

            while (true) {
                System.out.print("Enter command: ");
                String input = keyboard.nextLine().trim(); // 复用已有Scanner，读取字符串并去除首尾空格

                switch (input) { // 传入输入字符串作为判断表达式
                    case "m":
                        if (!evaluator.stack.isEmpty()) {
                            evaluator.stack.push(-evaluator.stack.pop());
                        } else {
                            System.out.println("Error: Stack is empty");
                        }
                        break;
                    case "r":
                        if (evaluator.stack.size() < 2) {
                            System.out.println("Error: Stack does not have enough elements");
                        } else {
                            int a = evaluator.stack.pop();
                            int b = evaluator.stack.pop();
                            evaluator.stack.push(a);
                            evaluator.stack.push(b);
                        }
                        break;
                    case "d":
                        if (!evaluator.stack.isEmpty()) {
                            int top = evaluator.stack.peek();
                            evaluator.stack.push(top);
                        } else {
                            System.out.println("Error: Stack is empty");
                        }
                        break;
                    case "p":
                        if (!evaluator.stack.isEmpty()) {
                            System.out.println("Top item: " + evaluator.stack.peek());
                        } else {
                            System.out.println("Error: Stack is empty");
                        }
                        break;
                    case "n":
                        if (!evaluator.stack.isEmpty()) {
                            System.out.println("Top item removed: " + evaluator.stack.pop());
                        } else {
                            System.out.println("Error: Stack is empty");
                        }
                        break;
                    case "f":
                        System.out.println("Stack contents: " + evaluator.stack);
                        break;
                    case "c":
                        evaluator.stack.clear();
                        System.out.println("Stack cleared");
                        break;
                    case "q":
                        System.out.println("Exiting program");
                        return;
                    case "h":
                    case "?":
                        printHelp();
                        break;
                    default:
                        System.out.println("Invalid command. Enter 'h' for help."); // 处理非法输入
                }
            }

        } while (again != null && again.equalsIgnoreCase("y"));
    }

    public int evaluate(String expr) {
        int op1, op2, result = 0;
        String token;
        Scanner parser = new Scanner(expr);

        while (parser.hasNext()) {
            token = parser.next();

            if (isOperator(token)) { // 如果是运算符则出栈计算
                op2 = stack.pop();
                op1 = stack.pop();
                result = evaluateSingleOperator(token.charAt(0), op1, op2);
                stack.push(result);
            } else {
                stack.push(Integer.parseInt(token)); // 数字入栈
            }
        }

        return result;
    }

    private boolean isOperator(String token) {
        return token.equals("+") || token.equals("-") ||
                token.equals("*") || token.equals("/") || token.equals("%");
    }

    private int evaluateSingleOperator(char operation, int op1, int op2) {
        return switch (operation) { // 简化为switch表达式
            case '+' -> op1 + op2;
            case '-' -> op1 - op2;
            case '*' -> op1 * op2;
            case '/' -> op1 / op2;
            case '%' -> op1 % op2;
            default -> 0;
        };
    }

    // 提取帮助打印逻辑，避免代码重复
    private static void printHelp() {
        System.out.println("Operations:");
        System.out.println("m - unary minus");
        System.out.println("r - exchange the top two items");
        System.out.println("d - duplicate top item on stack");
        System.out.println("p - print the top item");
        System.out.println("n - print and remove the top item");
        System.out.println("f - print all contents of the stack");
        System.out.println("c - clear the stack");
        System.out.println("q - quit");
        System.out.println("h or ? - print help message");
    }
}

额外优化说明 #

• 将stack改为非static成员，每个计算器实例拥有独立的栈，避免多实例数据干扰。
• 复用了主方法中已创建的keyboard Scanner，无需重新声明新的Scanner对象。
• 提取了帮助信息打印逻辑到printHelp()方法，减少代码冗余。
• 将evaluateSingleOperator中的switch语句简化为Java 12+支持的switch表达式，代码更简洁。
• 增加了对初始输入中q和h命令的处理，符合用户提示逻辑。

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