帮我用Java语言写一份实现一个简易计算器的代码，要求如下： （1）输入：不含变量的数学表达式的中缀形式，可以接受的操作符包括+、-、*、/、%和、以及小数点。 （2）输出：如果表达式正确，则输出表达式的结果，如果表达式非法，则输出错误信息。 （3）能够正确运算带括号的数学表达式的中缀形式。 （4）可以借助栈来实现，使用图形用户界面。

以下是一个简易计算器的Java代码，借助栈实现，使用Swing作为图形用户界面：

import java.awt.*;
import java.awt.event.*;
import javax.swing.*;

public class Calculator extends JFrame implements ActionListener {

    private static final long serialVersionUID = 1L;
    private JTextField textField;
    private JButton[] buttons;
    private String[] buttonLabels = {"7", "8", "9", "+", "4", "5", "6", "-", "1", "2", "3", "*", "0", ".", "C", "/", "(", ")", "%", "="};
    private Stack<Double> numStack;
    private Stack<Character> opStack;
    private boolean error;

    public Calculator() {
        // 设置窗口属性
        setTitle("简易计算器");
        setSize(300, 400);
        setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

        // 添加文本框
        textField = new JTextField();
        textField.setEditable(false);
        add(textField, BorderLayout.NORTH);

        // 添加按钮
        JPanel buttonPanel = new JPanel(new GridLayout(5, 4));
        buttons = new JButton[buttonLabels.length];
        for (int i = 0; i < buttonLabels.length; i++) {
            buttons[i] = new JButton(buttonLabels[i]);
            buttons[i].addActionListener(this);
            buttonPanel.add(buttons[i]);
        }
        add(buttonPanel, BorderLayout.CENTER);

        // 初始化栈
        numStack = new Stack<Double>();
        opStack = new Stack<Character>();
    }

    public void actionPerformed(ActionEvent e) {
        String label = e.getActionCommand();
        if (label.equals("C")) {
            // 清空文本框和栈
            textField.setText("");
            numStack.clear();
            opStack.clear();
            error = false;
        } else if (label.equals("=")) {
            // 计算表达式
            String expr = textField.getText();
            if (!expr.isEmpty()) {
                double result = calculate(expr);
                if (!error) {
                    textField.setText(Double.toString(result));
                } else {
                    textField.setText("错误");
                    error = false;
                }
            }
        } else {
            // 添加数字或操作符到文本框
            textField.setText(textField.getText() + label);
        }
    }

    private double calculate(String expr) {
        // 遍历表达式，将数字和操作符分别压入栈
        for (int i = 0; i < expr.length(); i++) {
            char c = expr.charAt(i);
            if (Character.isDigit(c) || c == '.') {
                // 数字
                StringBuilder sb = new StringBuilder();
                while (i < expr.length() && (Character.isDigit(expr.charAt(i)) || expr.charAt(i) == '.')) {
                    sb.append(expr.charAt(i));
                    i++;
                }
                i--;
                double num = Double.parseDouble(sb.toString());
                numStack.push(num);
            } else if (c == '+' || c == '-' || c == '*' || c == '/' || c == '%' || c == '(') {
                // 操作符或左括号
                if (!opStack.isEmpty() && priority(c) <= priority(opStack.peek()) && opStack.peek() != '(') {
                    // 栈顶操作符优先级高于或等于待压入操作符
                    double b = numStack.pop();
                    double a = numStack.pop();
                    char op = opStack.pop();
                    double result = operate(a, b, op);
                    numStack.push(result);
                    i--;
                } else {
                    opStack.push(c);
                }
            } else if (c == ')') {
                // 右括号
                while (!opStack.isEmpty() && opStack.peek() != '(') {
                    double b = numStack.pop();
                    double a = numStack.pop();
                    char op = opStack.pop();
                    double result = operate(a, b, op);
                    numStack.push(result);
                }
                if (opStack.isEmpty()) {
                    // 括号不匹配
                    error = true;
                    break;
                } else {
                    opStack.pop();
                }
            } else {
                // 非法字符
                error = true;
                break;
            }
        }
        // 处理剩余的操作符和数字
        while (!opStack.isEmpty()) {
            if (opStack.peek() == '(') {
                // 括号不匹配
                error = true;
                break;
            }
            double b = numStack.pop();
            double a = numStack.pop();
            char op = opStack.pop();
            double result = operate(a, b, op);
            numStack.push(result);
        }
        if (numStack.size() != 1) {
            // 表达式错误
            error = true;
        }
        double result = numStack.pop();
        return result;
    }

    private int priority(char op) {
        if (op == '+' || op == '-') {
            return 1;
        } else if (op == '*' || op == '/' || op == '%') {
            return 2;
        } else {
            return 0;
        }
    }

    private double operate(double a, double b, char op) {
        switch (op) {
            case '+':
                return a + b;
            case '-':
                return a - b;
            case '*':
                return a * b;
            case '/':
                if (b == 0) {
                    // 除数为零
                    error = true;
                    return 0;
                } else {
                    return a / b;
                }
            case '%':
                if (b == 0) {
                    // 除数为零
                    error = true;
                    return 0;
                } else {
                    return a % b;
                }
            default:
                return 0;
        }
    }

    public static void main(String[] args) {
        Calculator calculator = new Calculator();
        calculator.setVisible(true);
    }

}

运行该程序，将会弹出一个带有按钮和文本框的窗口，可以在文本框中输入数学表达式，然后点击“=”按钮计算结果。若表达式正确，则会在文本框中显示计算结果，否则会显示“错误”。