java，gui，文本框下有clear这个函数吗

Java中的文本框组件是可以使用setText("")方法来清空文本框中的内容。例如，假设你有一个名为textField的文本框组件，你可以使用以下代码清空文本框：

textField.setText("");

如果你希望在文本框中添加一个清空按钮，你可以创建一个按钮并将其与以下代码关联：

button.addActionListener(new ActionListener() {
    public void actionPerformed(ActionEvent e) {
        textField.setText("");
    }
});

在这个例子中，当用户单击按钮时，ActionListener将调用setText("")方法来清空文本框。

相关问题

javagui中做一个图形界面计算器包含四则运算，带Π的三角函数运算，

可以使用Java Swing来实现一个图形界面计算器。以下是一个基本的示例代码：

import java.awt.BorderLayout;
import java.awt.GridLayout;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.JPanel;
import javax.swing.JTextField;

public class Calculator extends JFrame implements ActionListener {
    private JTextField displayField; // 显示文本框
    private JPanel buttonPanel; // 按钮面板
    // 按钮数组
    private JButton[] buttons = {
        new JButton("7"), new JButton("8"), new JButton("9"), new JButton("/"),
        new JButton("4"), new JButton("5"), new JButton("6"), new JButton("*"),
        new JButton("1"), new JButton("2"), new JButton("3"), new JButton("-"),
        new JButton("0"), new JButton("."), new JButton("="), new JButton("+"),
        new JButton("sin"), new JButton("cos"), new JButton("tan"), new JButton("π")
    };

    public Calculator() {
        super("Calculator"); // 设置窗口标题
        setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        displayField = new JTextField("0", 16);
        displayField.setEditable(false); // 设置文本框不可编辑
        buttonPanel = new JPanel();
        buttonPanel.setLayout(new GridLayout(5, 4, 5, 5)); // 设置按钮面板为5行4列的网格布局
        // 将按钮添加到面板上并设置监听器
        for (JButton button : buttons) {
            button.addActionListener(this);
            buttonPanel.add(button);
        }
        // 将文本框和按钮面板添加到窗口上
        getContentPane().add(displayField, BorderLayout.NORTH);
        getContentPane().add(buttonPanel, BorderLayout.CENTER);
        pack(); // 调整窗口大小
        setVisible(true); // 显示窗口
    }

    public void actionPerformed(ActionEvent e) {
        String cmd = e.getActionCommand();
        if ("0123456789.".indexOf(cmd) != -1) { // 数字和小数点
            if (displayField.getText().equals("0") && !cmd.equals(".")) {
                displayField.setText(cmd);
            } else {
                displayField.setText(displayField.getText() + cmd);
            }
        } else if ("+-*/".indexOf(cmd) != -1) { // 四则运算
            double num1 = Double.parseDouble(displayField.getText());
            displayField.setText("0");
            String op = cmd;
            while (true) {
                String s = JOptionPane.showInputDialog("请输入第二个操作数：");
                if (s == null || s.equals("")) {
                    return;
                }
                try {
                    double num2 = Double.parseDouble(s);
                    double result = 0;
                    switch (op) {
                        case "+":
                            result = num1 + num2;
                            break;
                        case "-":
                            result = num1 - num2;
                            break;
                        case "*":
                            result = num1 * num2;
                            break;
                        case "/":
                            if (num2 == 0) {
                                JOptionPane.showMessageDialog(this, "除数不能为0！", "错误", JOptionPane.ERROR_MESSAGE);
                                return;
                            }
                            result = num1 / num2;
                            break;
                    }
                    displayField.setText(Double.toString(result));
                    break;
                } catch (NumberFormatException ex) {
                    JOptionPane.showMessageDialog(this, "请输入有效的数字！", "错误", JOptionPane.ERROR_MESSAGE);
                }
            }
        } else if ("sin cos tan".indexOf(cmd) != -1) { // 三角函数
            double num = Double.parseDouble(displayField.getText());
            double result = 0;
            switch (cmd) {
                case "sin":
                    result = Math.sin(num);
                    break;
                case "cos":
                    result = Math.cos(num);
                    break;
                case "tan":
                    result = Math.tan(num);
                    break;
            }
            displayField.setText(Double.toString(result));
        } else if (cmd.equals("π")) { // π
            displayField.setText(Double.toString(Math.PI));
        } else if (cmd.equals("=")) { // 等于号
            String expr = displayField.getText();
            try {
                double result = evaluate(expr);
                displayField.setText(Double.toString(result));
            } catch (IllegalArgumentException ex) {
                JOptionPane.showMessageDialog(this, ex.getMessage(), "错误", JOptionPane.ERROR_MESSAGE);
            }
        }
    }

    // 计算表达式的值
    private double evaluate(String expr) {
        expr = expr.replace("π", Double.toString(Math.PI));
        return CalculatorEngine.eval(expr);
    }

    public static void main(String[] args) {
        new Calculator();
    }
}

class CalculatorEngine {
    // 运算符栈
    private static Stack<String> operatorStack = new Stack<>();
    // 操作数栈
    private static Stack<Double> operandStack = new Stack<>();
    // 运算符优先级表
    private static final Map<String, Integer> precedenceTable = new HashMap<>();
    static {
        precedenceTable.put("+", 1);
        precedenceTable.put("-", 1);
        precedenceTable.put("*", 2);
        precedenceTable.put("/", 2);
    }

    // 计算表达式的值
    public static double eval(String expr) {
        operatorStack.clear();
        operandStack.clear();
        StringTokenizer tokenizer = new StringTokenizer(expr, "+-*/()", true);
        while (tokenizer.hasMoreTokens()) {
            String token = tokenizer.nextToken().trim();
            if (token.equals("")) {
                continue;
            }
            if (isNumber(token)) { // 数字
                double num = Double.parseDouble(token);
                operandStack.push(num);
            } else if (isOperator(token)) { // 运算符
                while (!operatorStack.isEmpty() && isOperator(operatorStack.peek()) && precedenceTable.get(token) <= precedenceTable.get(operatorStack.peek())) {
                    evalOperator();
                }
                operatorStack.push(token);
            } else if (token.equals("(")) { // 左括号
                operatorStack.push(token);
            } else if (token.equals(")")) { // 右括号
                while (!operatorStack.isEmpty() && !operatorStack.peek().equals("(")) {
                    evalOperator();
                }
                if (operatorStack.isEmpty() || !operatorStack.pop().equals("(")) {
                    throw new IllegalArgumentException("括号不匹配！");
                }
            } else { // 非法字符
                throw new IllegalArgumentException("非法字符：" + token);
            }
        }
        while (!operatorStack.isEmpty()) {
            if (operatorStack.peek().equals("(")) {
                throw new IllegalArgumentException("括号不匹配！");
            }
            evalOperator();
        }
        if (operandStack.size() != 1) {
            throw new IllegalArgumentException("表达式不正确！");
        }
        return operandStack.pop();
    }

    // 计算栈顶运算符
    private static void evalOperator() {
        String op = operatorStack.pop();
        if (operandStack.size() < 2) {
            throw new IllegalArgumentException("表达式不正确！");
        }
        double num2 = operandStack.pop();
        double num1 = operandStack.pop();
        double result = 0;
        switch (op) {
            case "+":
                result = num1 + num2;
                break;
            case "-":
                result = num1 - num2;
                break;
            case "*":
                result = num1 * num2;
                break;
            case "/":
                if (num2 == 0) {
                    throw new IllegalArgumentException("除数不能为0！");
                }
                result = num1 / num2;
                break;
        }
        operandStack.push(result);
    }

    // 判断字符串是否为数字
    private static boolean isNumber(String str) {
        try {
            Double.parseDouble(str);
            return true;
        } catch (NumberFormatException ex) {
            return false;
        }
    }

    // 判断字符串是否为运算符
    private static boolean isOperator(String str) {
        return "+-*/".indexOf(str) != -1;
    }
}

这个计算器支持四则运算、带π的三角函数运算，也可以直接输入表达式进行计算。当输入表达式时，计算器会自动将π替换成3.14159265358979323846。

用python编写一个gui界面的计算器

可以使用 Python 的 tkinter 库来编写一个 GUI 界面的计算器。

下面是一个简单的示例代码：

from tkinter import *

# 创建主窗口
root = Tk()
root.title("计算器")

# 定义计算函数
def calculate():
    result.set(eval(entry.get()))

# 定义清空函数
def clear():
    entry.delete(0, END)

# 定义返回函数
def backspace():
    entry.delete(len(entry.get())-1, END)

# 定义添加数字和符号函数
def add_text(txt):
    entry.insert(END, txt)

# 定义键盘绑定函数
def key_press(event):
    if event.char.isdigit():
        add_text(event.char)
    elif event.char in ['+', '-', '*', '/']:
        add_text(' ' + event.char + ' ')

# 定义结果字符串变量
result = StringVar()

# 创建计算器界面
entry = Entry(root, width=30)
entry.grid(row=0, column=0, columnspan=4, padx=5, pady=5)

btn_1 = Button(root, text="1", width=5, command=lambda:add_text("1"))
btn_1.grid(row=1, column=0, padx=5, pady=5)
btn_2 = Button(root, text="2", width=5, command=lambda:add_text("2"))
btn_2.grid(row=1, column=1, padx=5, pady=5)
btn_3 = Button(root, text="3", width=5, command=lambda:add_text("3"))
btn_3.grid(row=1, column=2, padx=5, pady=5)
btn_add = Button(root, text="+", width=5, command=lambda:add_text(" + "))
btn_add.grid(row=1, column=3, padx=5, pady=5)

btn_4 = Button(root, text="4", width=5, command=lambda:add_text("4"))
btn_4.grid(row=2, column=0, padx=5, pady=5)
btn_5 = Button(root, text="5", width=5, command=lambda:add_text("5"))
btn_5.grid(row=2, column=1, padx=5, pady=5)
btn_6 = Button(root, text="6", width=5, command=lambda:add_text("6"))
btn_6.grid(row=2, column=2, padx=5, pady=5)
btn_sub = Button(root, text="-", width=5, command=lambda:add_text(" - "))
btn_sub.grid(row=2, column=3, padx=5, pady=5)

btn_7 = Button(root, text="7", width=5, command=lambda:add_text("7"))
btn_7.grid(row=3, column=0, padx=5, pady=5)
btn_8 = Button(root, text="8", width=5, command=lambda:add_text("8"))
btn_8.grid(row=3, column=1, padx=5, pady=5)
btn_9 = Button(root, text="9", width=5, command=lambda:add_text("9"))
btn_9.grid(row=3, column=2, padx=5, pady=5)
btn_mul = Button(root, text="*", width=5, command=lambda:add_text(" * "))
btn_mul.grid(row=3, column=3, padx=5, pady=5)

btn_clear = Button(root, text="C", width=5, command=clear)
btn_clear.grid(row=4, column=0, padx=5, pady=5)
btn_0 = Button(root, text="0", width=5, command=lambda:add_text("0"))
btn_0.grid(row=4, column=1, padx=5, pady=5)
btn_back = Button(root, text="←", width=5, command=backspace)
btn_back.grid(row=4, column=2, padx=5, pady=5)
btn_div = Button(root, text="/", width=5, command=lambda:add_text(" / "))
btn_div.grid(row=4, column=3, padx=5, pady=5)

btn_equal = Button(root, text="=", width=30, command=calculate)
btn_equal.grid(row=5, column=0, columnspan=4, padx=5, pady=5)

# 绑定键盘事件
root.bind("<Key>", key_press)

root.mainloop()

这个计算器界面包括一个文本框、数字和符号按钮、清空、退格和等于按钮，可以使用鼠标或键盘输入。运行代码后会弹出计算器窗口。