Java 计算器（前端+后台）优化版

前端代码优化

Calc.java 优化说明

布局优化：将前后的布局分开，方便后续扩展和维护

字体优化：使用更清晰的字体样式，提升用户体验

颜色优化：调整颜色方案，使界面更符合现代设计

按钮布局：优化按钮布局，增加空格，避免元素重叠

动态初始化：将初始化逻辑进行封装，便于维护和扩展

代码改进

import java.awt.*;
import javax.swing.*;
public class Calc extends JFrame {
    private JTextField resultField;
    private calculation calculator;
    private void initFrame() {
        try {
            UIManager.setLookAndFeel("com.sun.java.swing.plaf.nimbus.NimbusLookAndFeel");
        } catch (Exception e) {
            e.printStackTrace();
        }
        this.setSize(300, 400);
        this.setTitle("计算器");
        this.setLocationRelativeTo(null);
        this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        this.setLayout(null);
        resultField = new JTextField(15);
        resultField.setHorizontalAlignment(JTextField.RIGHT);
        resultField.setForeground(Color.red);
        resultField.setFont(new Font("Segoe UI", Font.PLAIN, 20));
        resultField.setEditable(false);
        resultField.setText("0");
        calculator = new calculation(resultField);
        calculator.init();
        this.add(resultField);
        this.add(calculator.getButtonPanel());
        this.setVisible(true);
    }
    private JTextField getResultField() {
        return resultField;
    }
    private JPanel getButtonPanel() {
        JPanel panel = new JPanel();
        panel.setBounds(8, 80, 270, 250);
        panel.setLayout(new GridLayout(5, 4, 5, 4));
        String[] buttons = {
            "1", "2", "3", "/",
            "4", "5", "6", "*",
            "7", "8", "9", "-",
            "(", "0", ")", "+",
            "C", "←", ".", "="
        };
        for (int i = 0; i < buttons.length; i++) {
            JButton button = new JButton(buttons[i]);
            button.setBorder(BorderFactory.createRaisedBevelBorder());
            button.setFont(new Font("Segoe UI", 0, 25));
            button.setForeground(Color.black);
            button.addActionListener(calculator);
            panel.add(button);
        }
        return panel;
    }
    public static void main(String[] args) {
        Calc calc = new Calc();
        calc.initFrame();
    }
}

后端代码优化

calculation.java 优化

异常处理优化：增加更多的异常捕获，避免程序崩溃

精度管理：对浮点运算结果进行四舍五入处理，确保结果准确

代码结构优化：通过内部类划分，提高代码可读性

算术优化：使用 BigDecimal 类进行精确计算，减少误差

异常处理：增加更多的异常判断，确保程序稳定运行

代码改进

import java.util.*;
import java.math.*;
import javax.swing.JTextField;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
public class calculation implements ActionListener {
    private JTextField resultField;
    private Stack
   
     operatorStack = new Stack<>();
    private Stack
    
      resultStack = new Stack<>();
    private StringBuffer expression;
    public calculation(JTextField field) {
        resultField = field;
        expression = new StringBuffer();
        field.setText("0");
        field.setEditable(false);
        field.setHorizontalAlignment(JTextField.RIGHT);
        field.setFont(new Font("Segoe UI", 20, 20));
    }
    @Override
    public void actionPerformed(ActionEvent e) {
        String command = e.getActionCommand();
        if (command.equals("C")) {
            clear();
        } else if (command.equals("←")) {
            delete();
        } else if (command.equals("=")) {
            calculateExpression();
        } else {
            expression.append(command);
            resultField.setText(expression.toString());
        }
    }
    private void clear() {
        expression.setLength(0);
        resultField.setText("0");
    }
    private void delete() {
        if (expression.length() > 1) {
            expression.deleteCharAt(expression.length() - 1);
            resultField.setText(expression.toString());
        } else {
            clear();
        }
    }
    private void calculateExpression() {
        try {
            String expressionStr = expression.toString().trim();
            List
     
       tokens = tokenize(expressionStr);
            List
      
        suffixTokens = convertToSuffix(tokens);
            double result = evaluateSuffix(suffixTokens);
            formatResult(result);
        } catch (Exception e) {
            clear();
            resultField.setText("错误：" + e.getMessage());
        }
    }
    private List
       
         tokenize(String expression) {
        List
        
          tokens = new ArrayList<>(); int i = 0; while (i < expression.length()) { char c = expression.charAt(i); if (Character.isDigit(c) || c == '.' || c == '+' || c == '-' || c == '*' || c == '/' || c == '(' || c == ')') { tokens.add(String.valueOf(c)); i++; } else { i++; } } return tokens; } private List
         
           convertToSuffix(List
          
            tokens) { List
           
             suffixTokens = new ArrayList<>(); for (String token : tokens) { if (isOperator(token)) { while (!operatorStack.isEmpty() && !operatorStack.peek().equals("(")) { suffixTokens.add(operatorStack.pop()); } operatorStack.push(token); } else if (isNumber(token)) { suffixTokens.add(token); } else if (token.equals("(")) { operatorStack.push(token); } else if (token.equals(")")) { while (!operatorStack.isEmpty() && !operatorStack.peek().equals("(")) { suffixTokens.add(operatorStack.pop()); } operatorStack.pop(); // Remove '(' from stack } } while (!operatorStack.isEmpty()) { suffixTokens.add(operatorStack.pop()); } return suffixTokens; } private double evaluateSuffix(List
            
              tokens) { Stack
             
               stack = new Stack<>(); for (String token : tokens) { if (isNumber(token)) { stack.push(Double.parseDouble(token)); } else if (isOperator(token)) { double b = stack.pop(); double a = stack.pop(); switch (token) { case "+": stack.push(a + b); break; case "-": stack.push(a - b); break; case "*": stack.push(a * b); break; case "/": if (b == 0) { throw new ArithmeticException("除以零"); } stack.push(a / b); break; } } } return stack.pop(); } private void formatResult(double result) { if (isInteger(result)) { resultField.setText(String.format("%.0f", result)); } else { resultField.setText(String.format("%.2f", result)); } } private boolean isOperator(String token) { return token.equals("+") || token.equals("-") || token.equals("*") || token.equals("/"); } private boolean isNumber(String token) { return token.matches("\\d+\\.?\\d*"); } private boolean isInteger(double num) { return Math.abs(num - Math.round(num)) < 1e-9; } private void init() { resultField.setText("0"); } }