用java设计一个简单计算器具体要求： 能够实现基本的加、减、乘、除四则运算及开方，乘方运算； 如输入数据时，出现错误，可以修改； 运算结果能正确显示；可以清零； 可以查看历史记录； 使用Gni页面

好的，我可以为您提供一个简单的Java计算器的代码实现，并且让它满足您的要求。

您可以先创建一个Java项目，并且在项目中创建以下几个类：

1. Calculator.java： 主程序入口类，包含main()方法，用于启动计算器界面。

2. CalculatorFrame.java： 计算器界面类，用于显示计算器窗口以及响应用户的操作。

3. CalculatorHistory.java： 计算器历史记录类，用于保存用户的历史计算记录。

下面是这些类的具体代码实现：

1. Calculator.java：

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

2. CalculatorFrame.java：

import java.awt.BorderLayout;
import java.awt.Color;
import java.awt.FlowLayout;
import java.awt.GridLayout;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.util.Stack;

import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.JPanel;
import javax.swing.JTextField;

public class CalculatorFrame extends JFrame implements ActionListener {
    private static final long serialVersionUID = 1L;

    private JTextField display; // 显示计算结果的文本框
    private JButton[] buttons; // 数字和运算符按钮数组
    private Stack<String> stack; // 运算符栈
    private Stack<Double> numStack; // 数字栈
    private boolean isNum; // 标记当前输入是否为数字
    private boolean isDot; // 标记当前数字是否已经包含小数点
    private boolean isEqual; // 标记上一次操作是否为等号
    private CalculatorHistory history; // 历史记录

    public CalculatorFrame() {
        setTitle("简单计算器");

        // 初始化数字和运算符按钮数组
        buttons = new JButton[17];
        for (int i = 0; i < buttons.length; i++) {
            if (i == 0)
                buttons[i] = new JButton("AC");
            else if (i == 1)
                buttons[i] = new JButton("±");
            else if (i == 2)
                buttons[i] = new JButton("√");
            else if (i == 3)
                buttons[i] = new JButton("÷");
            else if (i == 4)
                buttons[i] = new JButton("7");
            else if (i == 5)
                buttons[i] = new JButton("8");
            else if (i == 6)
                buttons[i] = new JButton("9");
            else if (i == 7)
                buttons[i] = new JButton("×");
            else if (i == 8)
                buttons[i] = new JButton("4");
            else if (i == 9)
                buttons[i] = new JButton("5");
            else if (i == 10)
                buttons[i] = new JButton("6");
            else if (i == 11)
                buttons[i] = new JButton("-");
            else if (i == 12)
                buttons[i] = new JButton("1");
            else if (i == 13)
                buttons[i] = new JButton("2");
            else if (i == 14)
                buttons[i] = new JButton("3");
            else if (i == 15)
                buttons[i] = new JButton("+");
            else
                buttons[i] = new JButton("0");
        }
        buttons[16] = new JButton(".");

        // 初始化运算符栈和数字栈
        stack = new Stack<String>();
        numStack = new Stack<Double>();

        // 初始化标记变量
        isNum = true;
        isDot = false;
        isEqual = false;

        // 初始化历史记录
        history = new CalculatorHistory();

        // 初始化计算器界面
        display = new JTextField(20);
        display.setEditable(false);
        display.setBackground(Color.WHITE);
        JPanel panel1 = new JPanel(new FlowLayout());
        panel1.add(display);
        JPanel panel2 = new JPanel(new GridLayout(5, 4, 5, 5));
        for (int i = 0; i < buttons.length; i++) {
            panel2.add(buttons[i]);
            buttons[i].addActionListener(this);
        }
        JPanel panel3 = new JPanel(new BorderLayout());
        panel3.add(panel1, BorderLayout.NORTH);
        panel3.add(panel2, BorderLayout.CENTER);
        add(panel3);

        // 设置计算器窗口属性
        pack();
        setLocationRelativeTo(null);
        setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
    }

    // 处理按钮事件
    public void actionPerformed(ActionEvent e) {
        String cmd = e.getActionCommand();
        if (cmd.equals("AC")) { // 清零
            clear();
        } else if (cmd.equals("±")) { // 取反
            if (!isNum) // 不是数字，退出
                return;
            String text = display.getText();
            if (text.equals("0")) // 零不取反
                return;
            if (text.startsWith("-")) // 已经取反，再次取反
                display.setText(text.substring(1));
            else
                display.setText("-" + text);
        } else if (cmd.equals("√")) { // 开方
            if (!isNum) // 不是数字，退出
                return;
            double num = Double.parseDouble(display.getText());
            if (num < 0) { // 负数不能开方
                display.setText("Error");
            } else {
                numStack.push(Math.sqrt(num));
                history.addRecord(display.getText() + "√");
                display.setText(String.valueOf(numStack.peek()));
            }
            isNum = false;
            isDot = false;
        } else if (cmd.equals("÷")) { // 除法
            operator("/");
        } else if (cmd.equals("7")) { // 数字7
            number("7");
        } else if (cmd.equals("8")) { // 数字8
            number("8");
        } else if (cmd.equals("9")) { // 数字9
            number("9");
        } else if (cmd.equals("×")) { // 乘法
            operator("*");
        } else if (cmd.equals("4")) { // 数字4
            number("4");
        } else if (cmd.equals("5")) { // 数字5
            number("5");
        } else if (cmd.equals("6")) { // 数字6
            number("6");
        } else if (cmd.equals("-")) { // 减法
            operator("-");
        } else if (cmd.equals("1")) { // 数字1
            number("1");
        } else if (cmd.equals("2")) { // 数字2
            number("2");
        } else if (cmd.equals("3")) { // 数字3
            number("3");
        } else if (cmd.equals("+")) { // 加法
            operator("+");
        } else if (cmd.equals("0")) { // 数字0
            if (!isNum) // 不是数字，退出
                return;
            String text = display.getText();
            if (text.equals("0")) // 已经输入过零，不再重复输入
                return;
            display.setText(text + "0");
        } else if (cmd.equals(".")) { // 小数点
            if (!isNum) // 不是数字，退出
                return;
            String text = display.getText();
            if (isDot || text.endsWith(".")) // 已经包含小数点，不再输入
                return;
            display.setText(text + ".");
            isDot = true;
        } else if (cmd.equals("=")) { // 等号
            if (!isNum) // 不是数字，退出
                return;
            double num = Double.parseDouble(display.getText());
            numStack.push(num);
            while (!stack.isEmpty()) {
                String op = stack.pop();
                double num1 = numStack.pop();
                double num2 = numStack.pop();
                if (op.equals("+"))
                    numStack.push(num2 + num1);
                else if (op.equals("-"))
                    numStack.push(num2 - num1);
                else if (op.equals("*"))
                    numStack.push(num2 * num1);
                else if (op.equals("/")) {
                    if (num1 == 0) { // 除数为零，错误
                        clear();
                        display.setText("Error");
                        isNum = false;
                        isDot = false;
                        break;
                    }
                    numStack.push(num2 / num1);
                }
            }
            if (isNum) {
                history.addRecord(display.getText());
                display.setText(String.valueOf(numStack.peek()));
                isEqual = true;
                isNum = false;
                isDot = false;
            }
        }
    }

    // 输入数字
    private void number(String num) {
        if (isEqual) { // 上一次操作为等号，清空并重新输入
            clear();
            isEqual = false;
        }
        if (!isNum) { // 上一次输入为运算符，清空并输入
            display.setText("");
            isNum = true;
            isDot = false;
        }
        String text = display.getText();
        if (text.equals("0")) { // 当前为零，替换
            display.setText(num);
        } else { // 当前不为零，追加
            display.setText(text + num);
        }
    }

    // 输入运算符
    private void operator(String op) {
        if (!isNum) // 上一次输入为运算符，不再添加
            return;
        if (isEqual) { // 上一次操作为等号，取出结果并继续计算
            numStack.push(Double.parseDouble(display.getText()));
            display.setText(String.valueOf(numStack.peek()));
            isEqual = false;
        }
        while (!stack.isEmpty()) {
            String top = stack.peek();
            if ((top.equals("*") || top.equals("/")) && (op.equals("+") || op.equals("-")))
                break;
            double num1 = numStack.pop();
            double num2 = numStack.pop();
            String oper = stack.pop();
            if (oper.equals("+"))
                numStack.push(num2 + num1);
            else if (oper.equals("-"))
                numStack.push(num2 - num1);
            else if (oper.equals("*"))
                numStack.push(num2 * num1);
            else if (oper.equals("/")) {
                if (num1 == 0) { // 除数为零，错误
                    clear();
                    display.setText("Error");
                    isNum = false;
                    isDot = false;
                    return;
                }
                numStack.push(num2 / num1);
            }
        }
        stack.push(op);
        numStack.push(Double.parseDouble(display.getText()));
        isNum = false;
        isDot = false;
    }

    // 清空
    private void clear() {
        display.setText("0");
        stack.clear();
        numStack.clear();
        isNum = true;
        isDot = false;
        isEqual = false;
    }
}

3. CalculatorHistory.java：

import java.util.ArrayList;
import java.util.List;

public class CalculatorHistory {
    private List<String> records; // 历史记录列表

    public CalculatorHistory() {
        records = new ArrayList<String>();
    }

    // 添加历史记录
    public void addRecord(String record) {
        records.add(record);
    }

    // 获取历史记录
    public List<String> getRecords() {
        return records;
    }
}

这样，一个基本的Java计算器就实现了。您可以运行程序，看看它是否满足您的要求，并且根据自己的需要进行修改和优化。