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。

在应用程序窗体中安排两个文本框分别用来输入两个整数,三个按钮分别为“+”、“_”e “clear”,一个结果标签。点击按纽“+”将两文本框的数据做加法运算;点击按钮“_”做减法运算,点击按钮“clear”清空文本框与

结果标签的内容。

你可以使用如下的代码实现这个应用程序：

import tkinter as tk

class CalculatorApp(tk.Frame):
    def __init__(self, master=None):
        super().__init__(master)
        self.master = master
        self.master.title("Calculator App")
        self.pack()

        self.create_widgets()

    def create_widgets(self):
        # create first input box
        self.first_input_label = tk.Label(self, text="First Number:")
        self.first_input_label.grid(row=0, column=0)

        self.first_input = tk.Entry(self)
        self.first_input.grid(row=0, column=1)

        # create second input box
        self.second_input_label = tk.Label(self, text="Second Number:")
        self.second_input_label.grid(row=1, column=0)

        self.second_input = tk.Entry(self)
        self.second_input.grid(row=1, column=1)

        # create result label
        self.result_label = tk.Label(self, text="Result:")
        self.result_label.grid(row=2, column=0)

        self.result = tk.Label(self, text="")
        self.result.grid(row=2, column=1)

        # create buttons
        self.add_button = tk.Button(self, text="+", command=self.add_numbers)
        self.add_button.grid(row=3, column=0)

        self.subtract_button = tk.Button(self, text="-", command=self.subtract_numbers)
        self.subtract_button.grid(row=3, column=1)

        self.clear_button = tk.Button(self, text="Clear", command=self.clear_inputs)
        self.clear_button.grid(row=3, column=2)

    def add_numbers(self):
        try:
            first = int(self.first_input.get())
            second = int(self.second_input.get())
            result = first + second
            self.result.config(text=result)
        except ValueError:
            self.result.config(text="Invalid input")

    def subtract_numbers(self):
        try:
            first = int(self.first_input.get())
            second = int(self.second_input.get())
            result = first - second
            self.result.config(text=result)
        except ValueError:
            self.result.config(text="Invalid input")

    def clear_inputs(self):
        self.first_input.delete(0, tk.END)
        self.second_input.delete(0, tk.END)
        self.result.config(text="")

在这个应用程序中，我们使用了 Tkinter 库来创建 GUI 界面。我们创建了一个名为 CalculatorApp 的类，它继承自 Tkinter 的 Frame 类。

在 CalculatorApp 类的构造函数中，我们调用了父类的构造函数，并设置了应用程序的标题。我们还调用了 create_widgets() 方法来创建应用程序中的各个组件。

在 create_widgets() 方法中，我们创建了两个输入框、一个结果标签和三个按钮。我们使用 grid() 方法将它们放置在应用程序的不同行和列中。

在 add_numbers() 和 subtract_numbers() 方法中，我们获取了输入框中的值，并进行加法或减法运算。如果输入框中的内容不是整数，我们将结果标签中的文本设置为“Invalid input”。

在 clear_inputs() 方法中，我们使用 delete() 方法清空了输入框中的内容，并将结果标签中的文本设置为空字符串。

最后，我们创建了一个 CalculatorApp 对象，并调用了 Tkinter 的 mainloop() 方法来启动应用程序。