地图设计

FishC

卷帘红尘亦爱她 发表于 2024-04-07 14:05
@FishC1 用Java完成该代码编写一个日记本功能的程序， ...

import java.io.FileOutputStream;
import java.io.IOException;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.Scanner;

public class Diary {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        System.out.print("请输入姓名：");
        String name = scanner.nextLine();
        System.out.print("请输入日期（格式：yyyy-MM-dd）：");
        String date = scanner.nextLine();
        System.out.print("请输入天气：");
        String weather = scanner.nextLine();
        System.out.print("请输入日记标题：");
        String title = scanner.nextLine();
        System.out.print("请输入内容：");
        String content = scanner.nextLine();

        // 构造文件名
        String fileName = name + "日记本.txt";
        try (FileOutputStream fos = new FileOutputStream(fileName, true)) {
            SimpleDateFormat sdf = new SimpleDateFormat("yyyy年MM月dd日 HH:mm:ss");
            String currentTime = sdf.format(new Date());

            // 写入日记内容
            fos.write(("姓名：" + name + "\n").getBytes());
            fos.write(("日期：" + date + "\n").getBytes());
            fos.write(("时间：" + currentTime + "\n").getBytes());
            fos.write(("天气：" + weather + "\n").getBytes());
            fos.write(("标题：" + title + "\n").getBytes());
            fos.write(("内容：" + content + "\n").getBytes());
            fos.write("\n".getBytes());

            System.out.println("日记已保存至本地文件：" + fileName);
        } catch (IOException e) {
            System.out.println("保存失败：" + e.getMessage());
        }
    }
}

以上回复来自 FishC AI 小助理，如未能正确解答您的问题，请继续追问。

卷帘红尘亦爱她

@FishC1 利用Java Swing 图形组件开发一个可以进行简单的四则运算的图形化计算器。

FishC

卷帘红尘亦爱她 发表于 2024-04-11 13:54
@FishC1 利用Java Swing 图形组件开发一个可以进行简 ...

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

public class Calculator extends JFrame implements ActionListener {
    private JTextField inputField; // 输入框
    private JButton[] numberButtons; // 数字按钮数组
    private JButton[] operatorButtons; // 运算符按钮数组
    private JButton equalButton; // 等号按钮
    private JButton clearButton; // 清除按钮

    public Calculator() {
        setTitle("简单计算器");
        setLayout(new BorderLayout());
        setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

        // 初始化组件
        inputField = new JTextField();
        inputField.setHorizontalAlignment(JTextField.RIGHT);
        add(inputField, BorderLayout.NORTH);

        JPanel buttonPanel = new JPanel();
        buttonPanel.setLayout(new GridLayout(4, 4));

        numberButtons = new JButton[10];
        for (int i = 0; i < 10; i++) {
            numberButtons = new JButton(String.valueOf(i));
            numberButtons.addActionListener(this);
            buttonPanel.add(numberButtons);
        }

        operatorButtons = new JButton[4];
        operatorButtons[0] = new JButton("+");
        operatorButtons[1] = new JButton("-");
        operatorButtons[2] = new JButton("*");
        operatorButtons[3] = new JButton("/");
        for (int i = 0; i < 4; i++) {
            operatorButtons.addActionListener(this);
            buttonPanel.add(operatorButtons);
        }

        equalButton = new JButton("=");
        equalButton.addActionListener(this);
        buttonPanel.add(equalButton);

        clearButton = new JButton("C");
        clearButton.addActionListener(this);
        buttonPanel.add(clearButton);

        add(buttonPanel, BorderLayout.CENTER);

        pack();
        setLocationRelativeTo(null);
        setVisible(true);
    }

    public void actionPerformed(ActionEvent e) {
        Object source = e.getSource();
        if (source == clearButton) {
            inputField.setText(""); // 清空输入框
        } else if (source == equalButton) {
            String expression = inputField.getText(); // 获取输入表达式
            double result = calculate(expression); // 调用计算方法计算结果
            inputField.setText(String.valueOf(result)); // 显示结果
        } else {
            JButton button = (JButton) source;
            String text = button.getText();
            inputField.setText(inputField.getText() + text); // 在输入框中添加按钮上的数字或运算符
        }
    }

    // 计算表达式结果的方法
    private double calculate(String expression) {
        double result = 0;
        try {
            result = Double.parseDouble(expression);
        } catch (NumberFormatException e) {
            // 表达式不是一个数字，进行四则运算
            ScriptEngineManager manager = new ScriptEngineManager();
            ScriptEngine engine = manager.getEngineByName("js");
            try {
                result = (double) engine.eval(expression);
            } catch (ScriptException ex) {
                JOptionPane.showMessageDialog(this, "表达式错误！", "错误", JOptionPane.ERROR_MESSAGE);
            }
        }
        return result;
    }

    public static void main(String[] args) {
        SwingUtilities.invokeLater(new Runnable() {
            public void run() {
                new Calculator();
            }
        });
    }
}

这个示例使用了Java Swing库来创建一个简单的图形化计算器。计算器的界面包含一个文本字段和一些按钮，用于输入数字和执行运算。操作包括加、减、乘、除和等号。当用户点击等号按钮时，程序会获取文本字段中的表达式，并调用计算方法来计算结果，并在文本字段中显示结果。

以上回复来自 FishC AI 小助理，如未能正确解答您的问题，请继续追问。

卷帘红尘亦爱她

@FishC1通过用java 利用Java Swing 图形组件开发一个可以进行简单的四则运算的图形化计算器。

FishC

卷帘红尘亦爱她 发表于 2024-04-11 13:56
@FishC1通过用java 利用Java Swing 图形组件开发一个 ...

当然可以！下面是一个简单的Java Swing图形化计算器示例代码：

1. import javax.swing.*;
   
2. import java.awt.*;
   
3. import java.awt.event.ActionEvent;
   
4. import java.awt.event.ActionListener;
   
5. 
   
6. public class Calculator extends JFrame implements ActionListener {
   
7.     private JTextField textField;
   
8.     private JButton[] numberButtons;
   
9.     private JButton[] operatorButtons;
   
10.     private JButton equalButton;
    
11.     private JButton clearButton;
    
12.     private String display = "";
    
13. 
    
14.     public Calculator() {
    
15.         setTitle("简单计算器");
    
16.         setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
    
17.         setSize(300, 400);
    
18.         setLocationRelativeTo(null);
    
19. 
    
20.         textField = new JTextField();
    
21.         textField.setPreferredSize(new Dimension(300, 50));
    
22.         textField.setHorizontalAlignment(JTextField.RIGHT);
    
23. 
    
24.         numberButtons = new JButton[10];
    
25.         for (int i = 0; i < 10; i++) {
    
26.             numberButtons[i] = new JButton(String.valueOf(i));
    
27.             numberButtons[i].addActionListener(this);
    
28.         }
    
29. 
    
30.         operatorButtons = new JButton[4];
    
31.         operatorButtons[0] = new JButton("+");
    
32.         operatorButtons[1] = new JButton("-");
    
33.         operatorButtons[2] = new JButton("*");
    
34.         operatorButtons[3] = new JButton("/");
    
35.         for (JButton button : operatorButtons) {
    
36.             button.addActionListener(this);
    
37.         }
    
38. 
    
39.         equalButton = new JButton("=");
    
40.         equalButton.addActionListener(this);
    
41. 
    
42.         clearButton = new JButton("C");
    
43.         clearButton.addActionListener(this);
    
44. 
    
45.         setLayout(new GridLayout(5, 3));
    
46.         add(textField);
    
47.         for (JButton button : numberButtons) {
    
48.             add(button);
    
49.         }
    
50.         for (JButton button : operatorButtons) {
    
51.             add(button);
    
52.         }
    
53.         add(equalButton);
    
54.         add(clearButton);
    
55. 
    
56.         setVisible(true);
    
57.     }
    
58. 
    
59.     @Override
    
60.     public void actionPerformed(ActionEvent e) {
    
61.         if (e.getSource() == clearButton) {
    
62.             display = "";
    
63.         } else if (e.getSource() == equalButton) {
    
64.             try {
    
65.                 display = String.valueOf(eval(display));
    
66.             } catch (ArithmeticException ex) {
    
67.                 display = "错误";
    
68.             }
    
69.         } else {
    
70.             display += ((JButton) e.getSource()).getText();
    
71.         }
    
72. 
    
73.         textField.setText(display);
    
74.     }
    
75. 
    
76.     public static double eval(final String str) {
    
77.         return new Object() {
    
78.             int pos = -1, ch;
    
79. 
    
80.             void nextChar() {
    
81.                 ch = (++pos < str.length()) ? str.charAt(pos) : -1;
    
82.             }
    
83. 
    
84.             boolean eat(int charToEat) {
    
85.                 while (ch == ' ') {
    
86.                     nextChar();
    
87.                 }
    
88.                 if (ch == charToEat) {
    
89.                     nextChar();
    
90.                     return true;
    
91.                 }
    
92.                 return false;
    
93.             }
    
94. 
    
95.             double parse() {
    
96.                 nextChar();
    
97.                 double x = parseExpression();
    
98.                 if (pos < str.length()) {
    
99.                     throw new RuntimeException("意外字符: " + (char) ch);
    
100.                 }
     
101.                 return x;
     
102.             }
     
103. 
     
104.             double parseExpression() {
     
105.                 double x = parseTerm();
     
106.                 for (; ; ) {
     
107.                     if (eat('+')) {
     
108.                         x += parseTerm();
     
109.                     } else if (eat('-')) {
     
110.                         x -= parseTerm();
     
111.                     } else {
     
112.                         return x;
     
113.                     }
     
114.                 }
     
115.             }
     
116. 
     
117.             double parseTerm() {
     
118.                 double x = parseFactor();
     
119.                 for (; ; ) {
     
120.                     if (eat('*')) {
     
121.                         x *= parseFactor();
     
122.                     } else if (eat('/')) {
     
123.                         x /= parseFactor();
     
124.                     } else {
     
125.                         return x;
     
126.                     }
     
127.                 }
     
128.             }
     
129. 
     
130.             double parseFactor() {
     
131.                 if (eat('+')) {
     
132.                     return parseFactor();
     
133.                 }
     
134.                 if (eat('-')) {
     
135.                     return -parseFactor();
     
136.                 }
     
137. 
     
138.                 double x;
     
139.                 int startPos = this.pos;
     
140.                 if (eat('(')) {
     
141.                     x = parseExpression();
     
142.                     eat(')');
     
143.                 } else if ((ch >= '0' && ch <= '9') || ch == '.') {
     
144.                     while ((ch >= '0' && ch <= '9') || ch == '.') {
     
145.                         nextChar();
     
146.                     }
     
147.                     x = Double.parseDouble(str.substring(startPos, this.pos));
     
148.                 } else {
     
149.                     throw new RuntimeException("意外字符: " + (char) ch);
     
150.                 }
     
151. 
     
152.                 return x;
     
153.             }
     
154.         }.parse();
     
155.     }
     
156. 
     
157.     public static void main(String[] args) {
     
158.         SwingUtilities.invokeLater(new Runnable() {
     
159.             public void run() {
     
160.                 new Calculator();
     
161.             }
     
162.         });
     
163.     }
     
164. }

复制代码

运行上述代码，将弹出一个简单的图形化计算器窗口，你可以在这个窗口中进行四则运算。希望对你有帮助！

以上回复来自 FishC AI 小助理，如未能正确解答您的问题，请继续追问。

卷帘红尘亦爱她

@FishC1对每行代码进行注释

1.             int pos = -1, ch;
   
2. 
   
3.             void nextChar() {
   
4.                 ch = (++pos < str.length()) ? str.charAt(pos) : -1;
   
5.             }
   
6. 
   
7.             boolean eat(int charToEat) {
   
8.                 while (ch == ' ') {
   
9.                     nextChar();
   
10.                 }
    
11.                 if (ch == charToEat) {
    
12.                     nextChar();
    
13.                     return true;
    
14.                 }
    
15.                 return false;
    
16.             }
    
17. 
    
18.             double parse() {
    
19.                 nextChar();
    
20.                 double x = parseExpression();
    
21.                 if (pos < str.length()) {
    
22.                     throw new RuntimeException("意外字符: " + (char) ch);
    
23.                 }
    
24.                 return x;
    
25.             }
    
26. 
    
27.             double parseExpression() {
    
28.                 double x = parseTerm();
    
29.                 for (; ; ) {
    
30.                     if (eat('+')) {
    
31.                         x += parseTerm();
    
32.                     } else if (eat('-')) {
    
33.                         x -= parseTerm();
    
34.                     } else {
    
35.                         return x;
    
36.                     }
    
37.                 }
    
38.             }
    
39. 
    
40.             double parseTerm() {
    
41.                 double x = parseFactor();
    
42.                 for (; ; ) {
    
43.                     if (eat('*')) {
    
44.                         x *= parseFactor();
    
45.                     } else if (eat('/')) {
    
46.                         x /= parseFactor();
    
47.                     } else {
    
48.                         return x;
    
49.                     }
    
50.                 }
    
51.             }
    
52. 
    
53.             double parseFactor() {
    
54.                 if (eat('+')) {
    
55.                     return parseFactor();
    
56.                 }
    
57.                 if (eat('-')) {
    
58.                     return -parseFactor();
    
59.                 }
    
60. 
    
61.                 double x;
    
62.                 int startPos = this.pos;
    
63.                 if (eat('(')) {
    
64.                     x = parseExpression();
    
65.                     eat(')');
    
66.                 } else if ((ch >= '0' && ch <= '9') || ch == '.') {
    
67.                     while ((ch >= '0' && ch <= '9') || ch == '.') {
    
68.                         nextChar();
    
69.                     }
    
70.                     x = Double.parseDouble(str.substring(startPos, this.pos));
    
71.                 } else {
    
72.                     throw new RuntimeException("意外字符: " + (char) ch);
    
73.                 }
    
74. 
    
75.                 return x;
    
76.             }
    

复制代码

FishC

卷帘红尘亦爱她 发表于 2024-04-11 14:01
@FishC1对每行代码进行注释            int pos = -1, ...

下面是对每行代码进行注释的解释：

1. int pos = -1, ch; // 初始化位置和字符变量
   
2. 
   
3. void nextChar() { // 获取下一个字符
   
4.     ch = (++pos < str.length()) ? str.charAt(pos) : -1;
   
5. }
   
6. 
   
7. boolean eat(int charToEat) { // 检查并吃掉指定的字符
   
8.     while (ch == ' ') {
   
9.         nextChar();
   
10.     }
    
11.     if (ch == charToEat) {
    
12.         nextChar();
    
13.         return true;
    
14.     }
    
15.     return false;
    
16. }
    
17. 
    
18. double parse() { // 解析整个表达式
    
19.     nextChar();
    
20.     double x = parseExpression();
    
21.     if (pos < str.length()) {
    
22.         throw new RuntimeException("意外字符: " + (char) ch);
    
23.     }
    
24.     return x;
    
25. }
    
26. 
    
27. double parseExpression() { // 解析表达式中的加减法
    
28.     double x = parseTerm();
    
29.     for (;;) {
    
30.         if (eat('+')) {
    
31.             x += parseTerm();
    
32.         } else if (eat('-')) {
    
33.             x -= parseTerm();
    
34.         } else {
    
35.             return x;
    
36.         }
    
37.     }
    
38. }
    
39. 
    
40. double parseTerm() { // 解析表达式中的乘除法
    
41.     double x = parseFactor();
    
42.     for (;;) {
    
43.         if (eat('*')) {
    
44.             x *= parseFactor();
    
45.         } else if (eat('/')) {
    
46.             x /= parseFactor();
    
47.         } else {
    
48.             return x;
    
49.         }
    
50.     }
    
51. }
    
52. 
    
53. double parseFactor() { // 解析表达式中的因子
    
54.     if (eat('+')) { // 处理正号
    
55.         return parseFactor();
    
56.     }
    
57.     if (eat('-')) { // 处理负号
    
58.         return -parseFactor();
    
59.     }
    
60.     double x; // 临时变量
    
61.     int startPos = this.pos; // 记录起始位置
    
62.     if (eat('(')) { // 处理括号
    
63.         x = parseExpression();
    
64.         eat(')');
    
65.     } else if ((ch >= '0' && ch <= '9') || ch == '.') { // 处理数字
    
66.         while ((ch >= '0' && ch <= '9') || ch == '.') {
    
67.             nextChar();
    
68.         }
    
69.         x = Double.parseDouble(str.substring(startPos, this.pos));
    
70.     } else {
    
71.         throw new RuntimeException("意外字符: " + (char) ch);
    
72.     }
    
73.     return x;
    
74. }

复制代码

这段代码实现了一个简单的四则运算解析器。它能够从一个字符串中解析出数学表达式，并计算结果。其中，parse()方法调用parseExpression()方法来解析整个表达式，parseExpression()方法又调用parseTerm()方法来解析加减法，parseTerm()方法又调用parseFactor()方法来解析乘除法。eat()函数用于检查和吃掉指定的字符。整个过程通过递归和循环来实现对表达式的解析和计算。

以上回复来自 FishC AI 小助理，如未能正确解答您的问题，请继续追问。

卷帘红尘亦爱她

@FishC1对每行代码进行注释

1. import javax.swing.*;
   
2. import java.awt.*;
   
3. import java.awt.event.ActionEvent;
   
4. import java.awt.event.ActionListener;
   
5. class Calculator extends JFrame implements ActionListener {
   
6.     private JTextField textField;
   
7.     private JButton[] numberButtons;
   
8.     private JButton[] operatorButtons;
   
9.     private JButton equalButton;
   
10.     private JButton clearButton;
    
11.     private String display = "";
    
12. 
    
13.     public Calculator() {
    
14.         setTitle("简单计算器");
    
15.         setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
    
16.         setSize(300, 400);
    
17.         setLocationRelativeTo(null);
    
18. 
    
19.         textField = new JTextField();
    
20.         textField.setPreferredSize(new Dimension(300, 50));
    
21.         textField.setHorizontalAlignment(JTextField.RIGHT);
    
22. 
    
23.         numberButtons = new JButton[10];
    
24.         for (int i = 0; i < 10; i++) {
    
25.             numberButtons[i] = new JButton(String.valueOf(i));
    
26.             numberButtons[i].addActionListener(this);
    
27.         }
    
28. 
    
29.         operatorButtons = new JButton[4];
    
30.         operatorButtons[0] = new JButton("+");
    
31.         operatorButtons[1] = new JButton("-");
    
32.         operatorButtons[2] = new JButton("*");
    
33.         operatorButtons[3] = new JButton("/");
    
34.         for (JButton button : operatorButtons) {
    
35.             button.addActionListener(this);
    
36.         }
    
37. 
    
38.         equalButton = new JButton("=");
    
39.         equalButton.addActionListener(this);
    
40. 
    
41.         clearButton = new JButton("C");
    
42.         clearButton.addActionListener(this);
    
43. 
    
44.         setLayout(new GridLayout(5, 3));
    
45.         add(textField);
    
46.         for (JButton button : numberButtons) {
    
47.             add(button);
    
48.         }
    
49.         for (JButton button : operatorButtons) {
    
50.             add(button);
    
51.         }
    
52.         add(equalButton);
    
53.         add(clearButton);
    
54. 
    
55.         setVisible(true);
    
56.     }
    
57. 
    
58.     @Override
    
59.     public void actionPerformed(ActionEvent e) {
    
60.         if (e.getSource() == clearButton) {
    
61.             display = "";
    
62.         } else if (e.getSource() == equalButton) {
    
63.             try {
    
64.                 display = String.valueOf(eval(display));
    
65.             } catch (ArithmeticException ex) {
    
66.                 display = "错误";
    
67.             }
    
68.         } else {
    
69.             display += ((JButton) e.getSource()).getText();
    
70.         }
    
71. 
    
72.         textField.setText(display);
    
73.     }
    
74. 
    
75.     public static double eval(final String str) {
    
76.         return new Object() {
    
77.             int pos = -1, ch;
    
78. 
    
79.             void nextChar() {
    
80.                 ch = (++pos < str.length()) ? str.charAt(pos) : -1;
    
81.             }
    
82. 
    
83.             boolean eat(int charToEat) {
    
84.                 while (ch == ' ') {
    
85.                     nextChar();
    
86.                 }
    
87.                 if (ch == charToEat) {
    
88.                     nextChar();
    
89.                     return true;
    
90.                 }
    
91.                 return false;
    
92.             }
    
93. 
    
94.             double parse() {
    
95.                 nextChar();
    
96.                 double x = parseExpression();
    
97.                 if (pos < str.length()) {
    
98.                     throw new RuntimeException("意外字符: " + (char) ch);
    
99.                 }
    
100.                 return x;
     
101.             }
     
102. 
     
103.             double parseExpression() {
     
104.                 double x = parseTerm();
     
105.                 for (; ; ) {
     
106.                     if (eat('+')) {
     
107.                         x += parseTerm();
     
108.                     } else if (eat('-')) {
     
109.                         x -= parseTerm();
     
110.                     } else {
     
111.                         return x;
     
112.                     }
     
113.                 }
     
114.             }
     
115. 
     
116.             double parseTerm() {
     
117.                 double x = parseFactor();
     
118.                 for (; ; ) {
     
119.                     if (eat('*')) {
     
120.                         x *= parseFactor();
     
121.                     } else if (eat('/')) {
     
122.                         x /= parseFactor();
     
123.                     } else {
     
124.                         return x;
     
125.                     }
     
126.                 }
     
127.             }
     
128. 
     
129.             double parseFactor() {
     
130.                 if (eat('+')) {
     
131.                     return parseFactor();
     
132.                 }
     
133.                 if (eat('-')) {
     
134.                     return -parseFactor();
     
135.                 }
     
136. 
     
137.                 double x;
     
138.                 int startPos = this.pos;
     
139.                 if (eat('(')) {
     
140.                     x = parseExpression();
     
141.                     eat(')');
     
142.                 } else if ((ch >= '0' && ch <= '9') || ch == '.') {
     
143.                     while ((ch >= '0' && ch <= '9') || ch == '.') {
     
144.                         nextChar();
     
145.                     }
     
146.                     x = Double.parseDouble(str.substring(startPos, this.pos));
     
147.                 } else {
     
148.                     throw new RuntimeException("意外字符: " + (char) ch);
     
149.                 }
     
150. 
     
151.                 return x;
     
152.             }
     
153.         }.parse();
     
154.     }
     
155. 
     
156.     public static void main(String[] args) {
     
157.         SwingUtilities.invokeLater(new Runnable() {
     
158.             public void run() {
     
159.                 new Calculator();
     
160.             }
     
161.         });
     
162.     }
     
163. }

复制代码

FishC

卷帘红尘亦爱她 发表于 2024-04-11 14:04
@FishC1对每行代码进行注释import javax.swing.*;
im ...

下面是对每行代码进行注释的解释：

1. import javax.swing.*;
   
2. import java.awt.*;
   
3. import java.awt.event.ActionEvent;
   
4. import java.awt.event.ActionListener;
   
5. 
   
6. class Calculator extends JFrame implements ActionListener {
   
7.     private JTextField textField;
   
8.     private JButton[] numberButtons; // 数字按钮数组
   
9.     private JButton[] operatorButtons; // 操作符按钮数组
   
10.     private JButton equalButton;
    
11.     private JButton clearButton;
    
12.     private String display = "";
    
13. 
    
14.     public Calculator() {
    
15.         setTitle("简单计算器");
    
16.         setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
    
17.         setSize(300, 400);
    
18.         setLocationRelativeTo(null);
    
19. 
    
20.         textField = new JTextField();
    
21.         textField.setPreferredSize(new Dimension(300, 50));
    
22.         textField.setHorizontalAlignment(JTextField.RIGHT);
    
23. 
    
24.         numberButtons = new JButton[10];
    
25.         for (int i = 0; i < 10; i++) {
    
26.             numberButtons[i] = new JButton(String.valueOf(i));
    
27.             numberButtons[i].addActionListener(this);
    
28.         }
    
29. 
    
30.         operatorButtons = new JButton[4];
    
31.         operatorButtons[0] = new JButton("+");
    
32.         operatorButtons[1] = new JButton("-");
    
33.         operatorButtons[2] = new JButton("*");
    
34.         operatorButtons[3] = new JButton("/");
    
35.         for (JButton button : operatorButtons) {
    
36.             button.addActionListener(this);
    
37.         }
    
38. 
    
39.         equalButton = new JButton("=");
    
40.         equalButton.addActionListener(this);
    
41. 
    
42.         clearButton = new JButton("C");
    
43.         clearButton.addActionListener(this);
    
44. 
    
45.         setLayout(new GridLayout(5, 3));
    
46.         add(textField);
    
47.         for (JButton button : numberButtons) {
    
48.             add(button);
    
49.         }
    
50.         for (JButton button : operatorButtons) {
    
51.             add(button);
    
52.         }
    
53.         add(equalButton);
    
54.         add(clearButton);
    
55. 
    
56.         setVisible(true);
    
57.     }
    
58. 
    
59.     @Override
    
60.     public void actionPerformed(ActionEvent e) {
    
61.         if (e.getSource() == clearButton) { // 清除按钮点击事件
    
62.             display = "";
    
63.         } else if (e.getSource() == equalButton) { // 等于按钮点击事件
    
64.             try {
    
65.                 display = String.valueOf(eval(display)); // 调用eval方法计算表达式结果
    
66.             } catch (ArithmeticException ex) {
    
67.                 display = "错误";
    
68.             }
    
69.         } else { // 数字按钮和操作符按钮点击事件
    
70.             display += ((JButton) e.getSource()).getText();
    
71.         }
    
72.         textField.setText(display);
    
73.     }
    
74. 
    
75.     public static double eval(final String str) {
    
76.         return new Object() {
    
77.             int pos = -1, ch;
    
78. 
    
79.             void nextChar() {
    
80.                 ch = (++pos < str.length()) ? str.charAt(pos) : -1; // 获取下一个字符
    
81.             }
    
82. 
    
83.             boolean eat(int charToEat) {
    
84.                 while (ch == ' ') {
    
85.                     nextChar(); // 跳过空格
    
86.                 }
    
87.                 if (ch == charToEat) {
    
88.                     nextChar(); // 如果当前字符与目标字符匹配，则获取下一个字符
    
89.                     return true;
    
90.                 }
    
91.                 return false;
    
92.             }
    
93. 
    
94.             double parse() {
    
95.                 nextChar(); // 获取第一个字符
    
96.                 double x = parseExpression(); // 解析表达式
    
97.                 if (pos < str.length()) {
    
98.                     throw new RuntimeException("意外字符: " + (char) ch); // 如果还有剩余字符，抛出异常
    
99.                 }
    
100.                 return x;
     
101.             }
     
102. 
     
103.             double parseExpression() {
     
104.                 double x = parseTerm(); // 解析项
     
105.                 for (; ; ) {
     
106.                     if (eat('+')) { // 如果下一个字符是+，则解析下一项并相加
     
107.                         x += parseTerm();
     
108.                     } else if (eat('-')) { // 如果下一个字符是-，则解析下一项并相减
     
109.                         x -= parseTerm();
     
110.                     } else {
     
111.                         return x;
     
112.                     }
     
113.                 }
     
114.             }
     
115. 
     
116.             double parseTerm() {
     
117.                 double x = parseFactor(); // 解析因子
     
118.                 for (; ; ) {
     
119.                     if (eat('*')) { // 如果下一个字符是*，则解析下一个因子并相乘
     
120.                         x *= parseFactor();
     
121.                     } else if (eat('/')) { // 如果下一个字符是/，则解析下一个因子并相除
     
122.                         x /= parseFactor();
     
123.                     } else {
     
124.                         return x;
     
125.                     }
     
126.                 }
     
127.             }
     
128. 
     
129.             double parseFactor() {
     
130.                 if (eat('+')) { // 如果下一个字符是+，则解析下一个因子
     
131.                     return parseFactor();
     
132.                 }
     
133.                 if (eat('-')) { // 如果下一个字符是-，则解析下一个因子并取其相反数
     
134.                     return -parseFactor();
     
135.                 }
     
136.                 double x;
     
137.                 int startPos = this.pos;
     
138.                 if (eat('(')) { // 如果下一个字符是(，则解析表达式并跳过)
     
139.                     x = parseExpression();
     
140.                     eat(')');
     
141.                 } else if ((ch >= '0' && ch <= '9') || ch == '.') { // 如果下一个字符是数字或者小数点
     
142.                     while ((ch >= '0' && ch <= '9') || ch == '.') { // 解析连续的数字和小数点
     
143.                         nextChar();
     
144.                     }
     
145.                     x = Double.parseDouble(str.substring(startPos, this.pos)); // 将解析出的字符串转换为double类型
     
146.                 } else {
     
147.                     throw new RuntimeException("意外字符: " + (char) ch); // 非法字符，抛出异常
     
148.                 }
     
149.                 return x;
     
150.             }
     
151.         }.parse();
     
152.     }
     
153. 
     
154.     public static void main(String[] args) {
     
155.         new Calculator();
     
156.     }
     
157. }

复制代码

这个程序创建了一个简单的Swing图形化计算器。它包含一个文本框用于显示输入和结果，以及数字按钮、操作符按钮、等于按钮和清除按钮。用户可以通过点击按钮输入数字和操作符，然后通过点击等于按钮来计算结果。其中的eval函数实现了一个简单的表达式求值算法。

希望这个例子可以帮助你理解如何用Java Swing开发一个简单的图形化计算器！

以上回复来自 FishC AI 小助理，如未能正确解答您的问题，请继续追问。

卷帘红尘亦爱她

@FishC1对该代码进行修改使按钮大小不变文本框与清除键单独在第一行，剩下的键位以四行四列排列在文本框与清除键下边

1. import javax.swing.*;
   
2. import java.awt.*;
   
3. import java.awt.event.ActionEvent;
   
4. import java.awt.event.ActionListener;
   
5. 
   
6. // 计算器类，继承自JFrame，并实现ActionListener接口
   
7. class Calculator extends JFrame implements ActionListener {
   
8.     private JTextField textField; // 文本框，用于显示表达式和结果
   
9.     private JButton[] numberButtons; // 数字按钮数组
   
10.     private JButton[] operatorButtons; // 运算符按钮数组
    
11.     private JButton equalButton; // 等号按钮
    
12.     private JButton clearButton; // 清除按钮
    
13.     private String display = ""; // 用于存储当前显示的内容
    
14. 
    
15.     // 构造方法
    
16.     public Calculator() {
    
17.         setTitle("简单计算器"); // 设置窗口标题
    
18.         setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); // 设置关闭操作
    
19.         setSize(300, 400); // 设置窗口大小
    
20.         setLocationRelativeTo(null); // 设置窗口居中显示
    
21. 
    
22.         textField = new JTextField(); // 初始化文本框
    
23.         textField.setPreferredSize(new Dimension(300, 50)); // 设置文本框大小
    
24.         textField.setHorizontalAlignment(JTextField.RIGHT); // 设置文本框文本右对齐
    
25. 
    
26.         numberButtons = new JButton[10]; // 初始化数字按钮数组
    
27.         for (int i = 0; i < 10; i++) {
    
28.             numberButtons[i] = new JButton(String.valueOf(i)); // 创建数字按钮并添加事件监听
    
29.             numberButtons[i].addActionListener(this);
    
30.         }
    
31. 
    
32.         operatorButtons = new JButton[4]; // 初始化运算符按钮数组
    
33.         operatorButtons[0] = new JButton("+");
    
34.         operatorButtons[1] = new JButton("-");
    
35.         operatorButtons[2] = new JButton("*");
    
36.         operatorButtons[3] = new JButton("/");
    
37.         for (JButton button : operatorButtons) {
    
38.             button.addActionListener(this);
    
39.         }
    
40. 
    
41.         equalButton = new JButton("="); // 初始化等号按钮
    
42.         equalButton.addActionListener(this);
    
43. 
    
44.         clearButton = new JButton("C"); // 初始化清除按钮
    
45.         clearButton.addActionListener(this);
    
46. 
    
47.         setLayout(new GridLayout(4, 4)); // 设置布局为4行4列的网格布局
    
48.         add(textField); // 添加文本框到界面
    
49. 
    
50. // 添加清除按钮到界面，并设置为占据一整行
    
51.         add(clearButton);
    
52.         clearButton.setPreferredSize(new Dimension(300, 50)); // 设置清除按钮大小
    
53.         add(new JPanel()); // 添加一个空白面板，使清除按钮居中显示
    
54. 
    
55. // 添加数字按钮到界面
    
56.         for (JButton button : numberButtons) {
    
57.             add(button);
    
58.         }
    
59. 
    
60. // 添加运算符按钮到界面
    
61.         for (JButton button : operatorButtons) {
    
62.             add(button);
    
63.         }
    
64. 
    
65.         add(equalButton); // 添加等号按钮到界面
    
66. 
    
67. 
    
68.         setVisible(true); // 设置界面可见
    
69.     }
    
70. 
    
71.     // 处理按钮点击事件
    
72.     @Override
    
73.     public void actionPerformed(ActionEvent e) {
    
74.         if (e.getSource() == clearButton) {
    
75.             display = ""; // 清空显示内容
    
76.         } else if (e.getSource() == equalButton) {
    
77.             try {
    
78.                 display = String.valueOf(eval(display)); // 计算表达式并显示结果
    
79.             } catch (ArithmeticException ex) {
    
80.                 display = "错误"; // 若出现异常，显示错误信息
    
81.             }
    
82.         } else {
    
83.             display += ((JButton) e.getSource()).getText(); // 更新显示内容
    
84.         }
    
85. 
    
86.         textField.setText(display); // 更新文本框显示内容
    
87.     }
    
88. 
    
89.     // 计算表达式的方法
    
90.     public static double eval(final String str) {
    
91.         return new Object() {
    
92.             int pos = -1, ch;
    
93. 
    
94.             void nextChar() {
    
95.                 ch = (++pos < str.length()) ? str.charAt(pos) : -1;
    
96.             }
    
97. 
    
98.             boolean eat(int charToEat) {
    
99.                 while (ch == ' ') {
    
100.                     nextChar();
     
101.                 }
     
102.                 if (ch == charToEat) {
     
103.                     nextChar();
     
104.                     return true;
     
105.                 }
     
106.                 return false;
     
107.             }
     
108. 
     
109.             double parse() {
     
110.                 nextChar();
     
111.                 double x = parseExpression();
     
112.                 if (pos < str.length()) {
     
113.                     throw new RuntimeException("意外字符: " + (char) ch);
     
114.                 }
     
115.                 return x;
     
116.             }
     
117. 
     
118.             double parseExpression() {
     
119.                 double x = parseTerm();
     
120.                 for (; ; ) {
     
121.                     if (eat('+')) {
     
122.                         x += parseTerm();
     
123.                     } else if (eat('-')) {
     
124.                         x -= parseTerm();
     
125.                     } else {
     
126.                         return x;
     
127.                     }
     
128.                 }
     
129.             }
     
130. 
     
131.             double parseTerm() {
     
132.                 double x = parseFactor();
     
133.                 for (; ; ) {
     
134.                     if (eat('*')) {
     
135.                         x *= parseFactor();
     
136.                     } else if (eat('/')) {
     
137.                         x /= parseFactor();
     
138.                     } else {
     
139.                         return x;
     
140.                     }
     
141.                 }
     
142.             }
     
143. 
     
144.             double parseFactor() {
     
145.                 if (eat('+')) {
     
146.                     return parseFactor();
     
147.                 }
     
148.                 if (eat('-')) {
     
149.                     return -parseFactor();
     
150.                 }
     
151. 
     
152.                 double x;
     
153.                 int startPos = this.pos;
     
154.                 if (eat('(')) {
     
155.                     x = parseExpression();
     
156.                     eat(')');
     
157.                 } else if ((ch >= '0' && ch <= '9') || ch == '.') {
     
158.                     while ((ch >= '0' && ch <= '9') || ch == '.') {
     
159.                         nextChar();
     
160.                     }
     
161.                     x = Double.parseDouble(str.substring(startPos, this.pos));
     
162.                 } else {
     
163.                     throw new RuntimeException("意外字符: " + (char) ch);
     
164.                 }
     
165. 
     
166.                 return x;
     
167.             }
     
168.         }.parse();
     
169.     }
     
170. 
     
171.     // 主方法
     
172.     public static void main(String[] args) {
     
173.         SwingUtilities.invokeLater(new Runnable() {
     
174.             public void run() {
     
175.                 new Calculator(); // 创建计算器实例
     
176.             }
     
177.         });
     
178.     }
     
179. }
     

复制代码

FishC

卷帘红尘亦爱她 发表于 2024-04-11 14:22
@FishC1对该代码进行修改使按钮大小不变文本框与清除 ...

修改后的代码，按钮大小不变，文本框和清除键单独在第一行，剩下的键位以四行四列排列在文本框和清除键下边：

1. import javax.swing.*;
   
2. import java.awt.*;
   
3. import java.awt.event.ActionEvent;
   
4. import java.awt.event.ActionListener;
   
5. 
   
6. class Calculator extends JFrame implements ActionListener {
   
7.     private JTextField textField;
   
8.     private JButton[] numberButtons;
   
9.     private JButton[] operatorButtons;
   
10.     private JButton equalButton;
    
11.     private JButton clearButton;
    
12.     private String display = "";
    
13. 
    
14.     public Calculator() {
    
15.         setTitle("简单计算器");
    
16.         setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
    
17.         setSize(300, 400);
    
18.         setLocationRelativeTo(null);
    
19. 
    
20.         textField = new JTextField();
    
21.         textField.setPreferredSize(new Dimension(300, 50));
    
22.         textField.setHorizontalAlignment(JTextField.RIGHT);
    
23. 
    
24.         numberButtons = new JButton[10];
    
25.         for (int i = 0; i < 10; i++) {
    
26.             numberButtons[i] = new JButton(String.valueOf(i));
    
27.             numberButtons[i].addActionListener(this);
    
28.         }
    
29. 
    
30.         operatorButtons = new JButton[4];
    
31.         operatorButtons[0] = new JButton("+");
    
32.         operatorButtons[1] = new JButton("-");
    
33.         operatorButtons[2] = new JButton("*");
    
34.         operatorButtons[3] = new JButton("/");
    
35.         for (JButton button : operatorButtons) {
    
36.             button.addActionListener(this);
    
37.         }
    
38. 
    
39.         equalButton = new JButton("=");
    
40.         equalButton.addActionListener(this);
    
41. 
    
42.         clearButton = new JButton("C");
    
43.         clearButton.addActionListener(this);
    
44. 
    
45.         setLayout(new GridLayout(5, 4));
    
46.         add(textField);
    
47.         add(clearButton);
    
48.         clearButton.setPreferredSize(new Dimension(200, 50));
    
49.         add(new JPanel());
    
50. 
    
51.         for (int i = 7; i <= 9; i++) {
    
52.             add(numberButtons[i]);
    
53.         }
    
54.         add(operatorButtons[0]);
    
55. 
    
56.         for (int i = 4; i <= 6; i++) {
    
57.             add(numberButtons[i]);
    
58.         }
    
59.         add(operatorButtons[1]);
    
60. 
    
61.         for (int i = 1; i <= 3; i++) {
    
62.             add(numberButtons[i]);
    
63.         }
    
64.         add(operatorButtons[2]);
    
65. 
    
66.         add(numberButtons[0]);
    
67.         add(operatorButtons[3]);
    
68.         add(equalButton);
    
69. 
    
70.         setVisible(true);
    
71.     }
    
72. 
    
73.     @Override
    
74.     public void actionPerformed(ActionEvent e) {
    
75.         if (e.getSource() == clearButton) {
    
76.             display = "";
    
77.         } else if (e.getSource() == equalButton) {
    
78.             try {
    
79.                 display = String.valueOf(eval(display));
    
80.             } catch (ArithmeticException ex) {
    
81.                 display = "错误";
    
82.             }
    
83.         } else {
    
84.             display += ((JButton) e.getSource()).getText();
    
85.         }
    
86. 
    
87.         textField.setText(display);
    
88.     }
    
89. 
    
90.     public static double eval(final String str) {
    
91.         return new Object() {
    
92.             int pos = -1, ch;
    
93. 
    
94.             void nextChar() {
    
95.                 ch = (++pos < str.length()) ? str.charAt(pos) : -1;
    
96.             }
    
97. 
    
98.             boolean eat(int charToEat) {
    
99.                 while (ch == ' ') {
    
100.                     nextChar();
     
101.                 }
     
102.                 if (ch == charToEat) {
     
103.                     nextChar();
     
104.                     return true;
     
105.                 }
     
106.                 return false;
     
107.             }
     
108. 
     
109.             double parse() {
     
110.                 nextChar();
     
111.                 double x = parseExpression();
     
112.                 if (pos < str.length()) {
     
113.                     throw new RuntimeException("意外字符: " + (char) ch);
     
114.                 }
     
115.                 return x;
     
116.             }
     
117. 
     
118.             double parseExpression() {
     
119.                 double x = parseTerm();
     
120.                 for (; ; ) {
     
121.                     if (eat('+')) {
     
122.                         x += parseTerm();
     
123.                     } else if (eat('-')) {
     
124.                         x -= parseTerm();
     
125.                     } else {
     
126.                         return x;
     
127.                     }
     
128.                 }
     
129.             }
     
130. 
     
131.             double parseTerm() {
     
132.                 double x = parseFactor();
     
133.                 for (; ; ) {
     
134.                     if (eat('*')) {
     
135.                         x *= parseFactor();
     
136.                     } else if (eat('/')) {
     
137.                         x /= parseFactor();
     
138.                     } else {
     
139.                         return x;
     
140.                     }
     
141.                 }
     
142.             }
     
143. 
     
144.             double parseFactor() {
     
145.                 if (eat('+')) {
     
146.                     return parseFactor();
     
147.                 }
     
148.                 if (eat('-')) {
     
149.                     return -parseFactor();
     
150.                 }
     
151.                 double x;
     
152.                 int startPos = this.pos;
     
153.                 if (eat('(')) {
     
154.                     x = parseExpression();
     
155.                     eat(')');
     
156.                 } else if (ch >= '0' && ch <= '9') {
     
157.                     while (ch >= '0' && ch <= '9') {
     
158.                         nextChar();
     
159.                     }
     
160.                     x = Double.parseDouble(str.substring(startPos, this.pos));
     
161.                 } else {
     
162.                     throw new RuntimeException("意外字符: " + (char) ch);
     
163.                 }
     
164.                 return x;
     
165.             }
     
166.         }.parse();
     
167.     }
     
168. 
     
169.     public static void main(String[] args) {
     
170.         new Calculator();
     
171.     }
     
172. }

复制代码

现在按钮大小保持不变，文本框和清除键单独在第一行，剩下的键位以四行四列排列在文本框和清除键下方。

以上回复来自 FishC AI 小助理，如未能正确解答您的问题，请继续追问。

卷帘红尘亦爱她

@FishC1对该代码进行修改使按钮大小不变加入小数点键，文本框大小变为按钮的三倍与清除键单独在第一行，剩下的键位以四行四列排列在文本框与清除键下边

FishC

卷帘红尘亦爱她 发表于 2024-04-11 14:31
@FishC1对该代码进行修改使按钮大小不变加入小数点键 ...

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

// 计算器类，继承自JFrame，并实现ActionListener接口
class Calculator extends JFrame implements ActionListener {
    private JTextField textField; // 文本框，用于显示表达式和结果
    private JButton numberButtons; // 数字按钮数组
    private JButton operatorButtons; // 运算符按钮数组
    private JButton equalButton; // 等号按钮
    private JButton clearButton; // 清除按钮
    private String display = ""; // 用于存储当前显示的内容

    // 构造方法
    public Calculator() {
        setTitle("简单计算器"); // 设置窗口标题
        setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); // 设置关闭操作
        setSize(300, 400); // 设置窗口大小
        setLocationRelativeTo(null); // 设置窗口居中显示

        textField = new JTextField(); // 初始化文本框
        textField.setPreferredSize(new Dimension(300, 50)); // 设置文本框大小
        textField.setHorizontalAlignment(JTextField.RIGHT); // 设置文本框文本右对齐

        numberButtons = new JButton[11]; // 初始化数字按钮数组
        for (int i = 0; i < 10; i++) {
            numberButtons = new JButton(String.valueOf(i)); // 创建数字按钮并添加事件监听
            numberButtons.addActionListener(this);
        }
        numberButtons[10] = new JButton("."); // 创建小数点按钮
        numberButtons[10].addActionListener(this);

        operatorButtons = new JButton[4]; // 初始化运算符按钮数组
        operatorButtons[0] = new JButton("+");
        operatorButtons[1] = new JButton("-");
        operatorButtons[2] = new JButton("*");
        operatorButtons[3] = new JButton("/");
        for (JButton button : operatorButtons) {
            button.addActionListener(this);
        }

        equalButton = new JButton("="); // 初始化等号按钮
        equalButton.addActionListener(this);

        clearButton = new JButton("C"); // 初始化清除按钮
        clearButton.addActionListener(this);

        setLayout(new GridLayout(5, 4)); // 设置布局为5行4列的网格布局

        add(textField); // 添加文本框到界面
        textField.setPreferredSize(new Dimension(300, 150)); // 修改文本框大小，为按钮的3倍

        add(clearButton); // 添加清除按钮到界面，并设置为占据一整行
        clearButton.setPreferredSize(new Dimension(300, 50)); // 设置清除按钮大小

        add(new JPanel()); // 添加一个空白面板，使清除按钮居中显示

        // 添加数字按钮到界面
        for (JButton button : numberButtons) {
            add(button);
        }

        // 添加运算符按钮到界面
        for (JButton button : operatorButtons) {
            add(button);
        }

        add(equalButton); // 添加等号按钮到界面

        setVisible(true); // 设置界面可见
    }

    // 处理按钮点击事件
    @Override
    public void actionPerformed(ActionEvent e) {
        if (e.getSource() == clearButton) {
            display = ""; // 清空显示内容
        } else if (e.getSource() == equalButton) {
            try {
                display = String.valueOf(eval(display)); // 计算表达式并显示结果
            } catch (ArithmeticException ex) {
                display = "错误"; // 若出现异常，显示错误信息
            }
        } else {
            display += ((JButton) e.getSource()).getText(); // 更新显示内容
        }
        textField.setText(display); // 更新文本框显示内容
    }

    // 计算表达式的方法
    public static double eval(final String str) {
        return new Object() {
            int pos = -1, ch;

            void nextChar() {
                ch = (++pos < str.length()) ? str.charAt(pos) : -1;
            }

            boolean eat(int charToEat) {
                while (ch == ' ') {
                    nextChar();
                }
                if (ch == charToEat) {
                    nextChar();
                    return true;
                }
                return false;
            }

            double parse() {
                nextChar();
                double x = parseExpression();
                if (pos < str.length()) {
                    throw new RuntimeException("意外字符: " + (char) ch);
                }
                return x;
            }

            double parseExpression() {
                double x = parseTerm();
                for (; ; ) {
                    if (eat('+')) {
                        x += parseTerm();
                    } else if (eat('-')) {
                        x -= parseTerm();
                    } else {
                        return x;
                    }
                }
            }

            double parseTerm() {
                double x = parseFactor();
                for (; ; ) {
                    if (eat('*')) {
                        x *= parseFactor();
                    } else if (eat('/')) {
                        x /= parseFactor();
                    } else {
                        return x;
                    }
                }
            }

            double parseFactor() {
                if (eat('+')) {
                    return parseFactor();
                }
                if (eat('-')) {
                    return -parseFactor();
                }
                double x;
                int startPos = this.pos;
                if (eat('(')) {
                    x = parseExpression();
                    eat(')');
                } else if ((ch >= '0' && ch <= '9') || ch == '.') {
                    while ((ch >= '0' && ch <= '9') || ch == '.') {
                        nextChar();
                    }
                    x = Double.parseDouble(str.substring(startPos, this.pos));
                } else {
                    throw new RuntimeException("意外字符: " + (char) ch);
                }
                return x;
            }
        }.parse();
    }

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

以上回复来自 FishC AI 小助理，如未能正确解答您的问题，请继续追问。

卷帘红尘亦爱她

@FishC1对该代码进行修改使按钮大小不变加入小数点键，文本框大小变为按钮的三倍与清除键单独在第一行，剩下的键位以四行四列排列在文本框与清除键下边

1. import javax.swing.*;
   
2. import java.awt.*;
   
3. import java.awt.event.ActionEvent;
   
4. import java.awt.event.ActionListener;
   
5. 
   
6. class Calculator extends JFrame implements ActionListener {
   
7.     private JTextField textField;
   
8.     private JButton[] numberButtons;
   
9.     private JButton[] operatorButtons;
   
10.     private JButton equalButton;
    
11.     private JButton clearButton;
    
12.     private String display = "";
    
13. 
    
14.     public Calculator() {
    
15.         setTitle("简单计算器");
    
16.         setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
    
17.         setSize(400, 400);
    
18.         setLocationRelativeTo(null);
    
19. 
    
20.         textField = new JTextField();
    
21.         textField.setPreferredSize(new Dimension(300, 50)); // 修改文本框长度为键位长度的三倍
    
22.         textField.setHorizontalAlignment(JTextField.RIGHT);
    
23. 
    
24.         numberButtons = new JButton[10];
    
25.         for (int i = 0; i < 10; i++) {
    
26.             numberButtons[i] = new JButton(String.valueOf(i));
    
27.             numberButtons[i].addActionListener(this);
    
28.         }
    
29. 
    
30.         operatorButtons = new JButton[4];
    
31.         operatorButtons[0] = new JButton("+");
    
32.         operatorButtons[1] = new JButton("-");
    
33.         operatorButtons[2] = new JButton("*");
    
34.         operatorButtons[3] = new JButton("/");
    
35.         for (JButton button : operatorButtons) {
    
36.             button.addActionListener(this);
    
37.         }
    
38. 
    
39.         equalButton = new JButton("=");
    
40.         equalButton.addActionListener(this);
    
41. 
    
42.         clearButton = new JButton("C");
    
43.         clearButton.addActionListener(this);
    
44. 
    
45.         setLayout(new GridLayout(5, 4));
    
46.         add(textField);
    
47.         add(clearButton);
    
48.         clearButton.setPreferredSize(new Dimension(50, 50));
    
49.         add(new JPanel());
    
50. 
    
51.         for (int i = 7; i <= 9; i++) {
    
52.             add(numberButtons[i]);
    
53.         }
    
54.         add(operatorButtons[0]);
    
55. 
    
56.         for (int i = 4; i <= 6; i++) {
    
57.             add(numberButtons[i]);
    
58.         }
    
59.         add(operatorButtons[1]);
    
60. 
    
61.         for (int i = 1; i <= 3; i++) {
    
62.             add(numberButtons[i]);
    
63.         }
    
64.         add(operatorButtons[2]);
    
65. 
    
66.         add(numberButtons[0]);
    
67.         add(operatorButtons[3]);
    
68.         add(equalButton);
    
69. 
    
70.         setVisible(true);
    
71.     }
    
72. 
    
73.     @Override
    
74.     public void actionPerformed(ActionEvent e) {
    
75.         if (e.getSource() == clearButton) {
    
76.             display = "";
    
77.         } else if (e.getSource() == equalButton) {
    
78.             try {
    
79.                 display = String.valueOf(eval(display));
    
80.             } catch (ArithmeticException ex) {
    
81.                 display = "错误";
    
82.             }
    
83.         } else {
    
84.             display += ((JButton) e.getSource()).getText();
    
85.         }
    
86. 
    
87.         textField.setText(display);
    
88.     }
    
89. 
    
90.     public static double eval(final String str) {
    
91.         return new Object() {
    
92.             int pos = -1, ch;
    
93. 
    
94.             void nextChar() {
    
95.                 ch = (++pos < str.length()) ? str.charAt(pos) : -1;
    
96.             }
    
97. 
    
98.             boolean eat(int charToEat) {
    
99.                 while (ch == ' ') {
    
100.                     nextChar();
     
101.                 }
     
102.                 if (ch == charToEat) {
     
103.                     nextChar();
     
104.                     return true;
     
105.                 }
     
106.                 return false;
     
107.             }
     
108. 
     
109.             double parse() {
     
110.                 nextChar();
     
111.                 double x = parseExpression();
     
112.                 if (pos < str.length()) {
     
113.                     throw new RuntimeException("意外字符: " + (char) ch);
     
114.                 }
     
115.                 return x;
     
116.             }
     
117. 
     
118.             double parseExpression() {
     
119.                 double x = parseTerm();
     
120.                 for (; ; ) {
     
121.                     if (eat('+')) {
     
122.                         x += parseTerm();
     
123.                     } else if (eat('-')) {
     
124.                         x -= parseTerm();
     
125.                     } else {
     
126.                         return x;
     
127.                     }
     
128.                 }
     
129.             }
     
130. 
     
131.             double parseTerm() {
     
132.                 double x = parseFactor();
     
133.                 for (; ; ) {
     
134.                     if (eat('*')) {
     
135.                         x *= parseFactor();
     
136.                     } else if (eat('/')) {
     
137.                         x /= parseFactor();
     
138.                     } else {
     
139.                         return x;
     
140.                     }
     
141.                 }
     
142.             }
     
143. 
     
144.             double parseFactor() {
     
145.                 if (eat('+')) {
     
146.                     return parseFactor();
     
147.                 }
     
148.                 if (eat('-')) {
     
149.                     return -parseFactor();
     
150.                 }
     
151.                 double x;
     
152.                 int startPos = this.pos;
     
153.                 if (eat('(')) {
     
154.                     x = parseExpression();
     
155.                     eat(')');
     
156.                 } else if (ch >= '0' && ch <= '9') {
     
157.                     while (ch >= '0' && ch <= '9') {
     
158.                         nextChar();
     
159.                     }
     
160.                     x = Double.parseDouble(str.substring(startPos, this.pos));
     
161.                 } else {
     
162.                     throw new RuntimeException("意外字符: " + (char) ch);
     
163.                 }
     
164.                 return x;
     
165.             }
     
166.         }.parse();
     
167.     }
     
168. 
     
169.     public static void main(String[] args) {
     
170.         new Calculator();
     
171.     }
     
172. }
     

复制代码

FishC

卷帘红尘亦爱她 发表于 2024-04-11 14:33
@FishC1对该代码进行修改使按钮大小不变加入小数点键 ...

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

class Calculator extends JFrame implements ActionListener {
    private JTextField textField;
    private JButton[] numberButtons;
    private JButton[] operatorButtons;
    private JButton decimalButton;
    private JButton equalButton;
    private JButton clearButton;
    private String display = "";

    public Calculator() {
        setTitle("简单计算器");
        setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        setSize(400, 500); // 修改窗口高度为500
        setLocationRelativeTo(null);

        textField = new JTextField();
        textField.setPreferredSize(new Dimension(300, 150)); // 修改文本框长度为按钮宽度的三倍
        textField.setHorizontalAlignment(JTextField.RIGHT);

        numberButtons = new JButton[10];
        for (int i = 0; i < 10; i++) {
            numberButtons = new JButton(String.valueOf(i));
            numberButtons.addActionListener(this);
        }

        operatorButtons = new JButton[4];
        operatorButtons[0] = new JButton("+");
        operatorButtons[1] = new JButton("-");
        operatorButtons[2] = new JButton("*");
        operatorButtons[3] = new JButton("/");
        for (JButton button : operatorButtons) {
            button.addActionListener(this);
        }

        decimalButton = new JButton(".");
        decimalButton.addActionListener(this);

        equalButton = new JButton("=");
        equalButton.addActionListener(this);

        clearButton = new JButton("C");
        clearButton.addActionListener(this);

        setLayout(new GridLayout(6, 4)); // 修改布局为6行4列
        add(textField);
        add(clearButton);
        clearButton.setPreferredSize(new Dimension(100, 50)); // 修改清除按钮宽度
        add(decimalButton);

        for (int i = 7; i <= 9; i++) {
            add(numberButtons);
        }
        add(operatorButtons[0]);

        for (int i = 4; i <= 6; i++) {
            add(numberButtons);
        }
        add(operatorButtons[1]);

        for (int i = 1; i <= 3; i++) {
            add(numberButtons);
        }
        add(operatorButtons[2]);

        add(numberButtons[0]);
        add(equalButton);
        add(operatorButtons[3]);

        setVisible(true);
    }

    @Override
    public void actionPerformed(ActionEvent e) {
        if (e.getSource() == clearButton) {
            display = "";
        } else if (e.getSource() == equalButton) {
            try {
                display = String.valueOf(eval(display));
            } catch (ArithmeticException ex) {
                display = "错误";
            }
        } else {
            display += ((JButton) e.getSource()).getText();
        }
        textField.setText(display);
    }

    public static double eval(final String str) {
        return new Object() {
            int pos = -1, ch;

            void nextChar() {
                ch = (++pos < str.length()) ? str.charAt(pos) : -1;
            }

            boolean eat(int charToEat) {
                while (ch == ' ') {
                    nextChar();
                }
                if (ch == charToEat) {
                    nextChar();
                    return true;
                }
                return false;
            }

            double parse() {
                nextChar();
                double x = parseExpression();
                if (pos < str.length()) {
                    throw new RuntimeException("意外字符: " + (char) ch);
                }
                return x;
            }

            double parseExpression() {
                double x = parseTerm();
                for (; ; ) {
                    if (eat('+')) {
                        x += parseTerm();
                    } else if (eat('-')) {
                        x -= parseTerm();
                    } else {
                        return x;
                    }
                }
            }

            double parseTerm() {
                double x = parseFactor();
                for (; ; ) {
                    if (eat('*')) {
                        x *= parseFactor();
                    } else if (eat('/')) {
                        x /= parseFactor();
                    } else {
                        return x;
                    }
                }
            }

            double parseFactor() {
                if (eat('+')) {
                    return parseFactor();
                }
                if (eat('-')) {
                    return -parseFactor();
                }
                double x;
                int startPos = this.pos;
                if (eat('(')) {
                    x = parseExpression();
                    eat(')');
                } else if ((ch >= '0' && ch <= '9') || ch == '.') { // 添加小数点判断
                    while ((ch >= '0' && ch <= '9') || ch == '.') {
                        nextChar();
                    }
                    x = Double.parseDouble(str.substring(startPos, this.pos));
                } else {
                    throw new RuntimeException("意外字符: " + (char) ch);
                }
                return x;
            }
        }.parse();
    }
}

以上回复来自 FishC AI 小助理，如未能正确解答您的问题，请继续追问。

卷帘红尘亦爱她

@FishC1利用Java Swing 图形组件开发一个可以进行简单的四则运算的图形化计算器，有+，-，*，/，.和清除键，且文本框和清除键在第一行，其他的在下方以4*4分布

FishC

卷帘红尘亦爱她 发表于 2024-04-11 14:38
@FishC1利用Java Swing 图形组件开发一个可以进行简单 ...

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

public class Calculator extends JFrame implements ActionListener {
    private JTextField textField;
    private JButton[] numberButtons;
    private JButton[] operatorButtons;
    private JButton equalButton;
    private JButton clearButton;
    private String display = "";

    public Calculator() {
        setTitle("简单计算器");
        setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        setSize(400, 400);
        setLocationRelativeTo(null);

        // 创建文本框和清除键
        textField = new JTextField();
        textField.setPreferredSize(new Dimension(300, 50));
        textField.setHorizontalAlignment(JTextField.RIGHT);

        clearButton = new JButton("C");
        clearButton.addActionListener(this);

        // 创建数字键按钮
        numberButtons = new JButton[10];
        for (int i = 0; i < 10; i++) {
            numberButtons = new JButton(String.valueOf(i));
            numberButtons.addActionListener(this);
        }

        // 创建运算符按钮
        operatorButtons = new JButton[4];
        operatorButtons[0] = new JButton("+");
        operatorButtons[1] = new JButton("-");
        operatorButtons[2] = new JButton("*");
        operatorButtons[3] = new JButton("/");
        for (int i = 0; i < 4; i++) {
            operatorButtons.addActionListener(this);
        }

        // 创建等号按钮
        equalButton = new JButton("=");
        equalButton.addActionListener(this);

        // 设置布局为网格布局，5行4列
        setLayout(new GridLayout(5, 4));
        add(textField);
        add(clearButton);
        add(new JPanel());
        
        // 添加数字按钮
        for (int i = 7; i <= 9; i++) {
            add(numberButtons);
        }
        add(operatorButtons[0]); // +
        
        for (int i = 4; i <= 6; i++) {
            add(numberButtons);
        }
        add(operatorButtons[1]); // -
        
        for (int i = 1; i <= 3; i++) {
            add(numberButtons);
        }
        add(operatorButtons[2]); // *
        
        add(numberButtons[0]);
        add(operatorButtons[3]); // /
        add(new JButton("."));
        add(equalButton);

        setVisible(true);
    }

    public void actionPerformed(ActionEvent e) {
        JButton source = (JButton) e.getSource();
        if (source == clearButton) { // 清除键
            display = "";
        } else if (source == equalButton) { // 等号键
            display = evaluate(display);
        } else { // 数字键或运算符键
            display += source.getText();
        }
        textField.setText(display);
    }

    private String evaluate(String expression) {
        try {
            return String.valueOf(eval(expression));
        } catch (Exception e) {
            return "Error";
        }
    }

    private double eval(String expression) {
        return new Object() {
            int pos = -1, ch;

            void nextChar() {
                ch = (++pos < expression.length()) ? expression.charAt(pos) : -1;
            }

            boolean eat(int charToEat) {
                while (ch == ' ') nextChar();
                if (ch == charToEat) {
                    nextChar();
                    return true;
                }
                return false;
            }

            double parse() {
                nextChar();
                double x = parseExpression();
                if (pos < expression.length()) throw new RuntimeException("Unexpected: " + (char) ch);
                return x;
            }

            double parseExpression() {
                double x = parseTerm();
                for (;;) {
                    if (eat('+')) x += parseTerm();
                    else if (eat('-')) x -= parseTerm();
                    else return x;
                }
            }

            double parseTerm() {
                double x = parseFactor();
                for (;;) {
                    if (eat('*')) x *= parseFactor();
                    else if (eat('/')) x /= parseFactor();
                    else return x;
                }
            }

            double parseFactor() {
                if (eat('+')) return parseFactor();
                if (eat('-')) return -parseFactor();

                double x;
                int startPos = this.pos;
                if (eat('(')) {
                    x = parseExpression();
                    eat(')');
                } else if ((ch >= '0' && ch <= '9') || ch == '.') {
                    while ((ch >= '0' && ch <= '9') || ch == '.') nextChar();
                    x = Double.parseDouble(expression.substring(startPos, this.pos));
                } else {
                    throw new RuntimeException("Unexpected: " + (char) ch);
                }

                if (eat('^')) x = Math.pow(x, parseFactor());

                return x;
            }
        }.parse();
    }

    public static void main(String[] args) {
        SwingUtilities.invokeLater(new Runnable() {
            public void run() {
                new Calculator();
            }
        });
    }
}

以上回复来自 FishC AI 小助理，如未能正确解答您的问题，请继续追问。

卷帘红尘亦爱她

@FishC1通过该代码对你所书写代码进行优化

1. import javax.script.ScriptEngine;
   
2. import javax.script.ScriptEngineManager;
   
3. import javax.swing.*;
   
4. import java.awt.*;
   
5. import java.awt.event.ActionEvent;
   
6. import java.awt.event.ActionListener;
   
7. 
   
8. 
   
9. class Calculator extends JFrame{
   
10. 
    
11.     //定义JTextField 显示的字符串
    
12.     String string = new String();
    
13. 
    
14.     public Calculator(){
    
15.         // 创建一个 Container 容器并初始化。
    
16.         Container container=getContentPane();
    
17.         //设置容器布局：网格布局样式，5行1列，水平间距50，垂直间距10
    
18.         container.setLayout(new GridLayout(5,1,50,10));
    
19.         // 创建一个 JTextField 对象并初始化。 JTextField 是用于显示操作和计算结果的文本框。
    
20.         // 参数 26 表明可以显示 26 列的文本内容
    
21.         JTextField result_TextField = new JTextField(26);
    
22.         //把字符串赋值给文本框
    
23.         result_TextField.setText(string);
    
24.         //创建一个带文本的按钮-->清除键
    
25.         JButton clear_Button = new JButton("    clear     ");
    
26.         //给按钮添加事件监听器
    
27.         clear_Button.addActionListener(clearButtonListener(result_TextField));
    
28.         //数字键0到9
    
29.         JButton button0 = new JButton("0");
    
30.         button0.addActionListener(numbersAndOperatorsListener(result_TextField));
    
31.         JButton button1 = new JButton("1");
    
32.         button1.addActionListener(numbersAndOperatorsListener(result_TextField));
    
33.         JButton button2 = new JButton("2");
    
34.         button2.addActionListener(numbersAndOperatorsListener(result_TextField));
    
35.         JButton button3 = new JButton("3");
    
36.         button3.addActionListener(numbersAndOperatorsListener(result_TextField));
    
37.         JButton button4 = new JButton("4");
    
38.         button4.addActionListener(numbersAndOperatorsListener(result_TextField));
    
39.         JButton button5 = new JButton("5");
    
40.         button5.addActionListener(numbersAndOperatorsListener(result_TextField));
    
41.         JButton button6 = new JButton("6");
    
42.         button6.addActionListener(numbersAndOperatorsListener(result_TextField));
    
43.         JButton button7 = new JButton("7");
    
44.         button7.addActionListener(numbersAndOperatorsListener(result_TextField));
    
45.         JButton button8 = new JButton("8");
    
46.         button8.addActionListener(numbersAndOperatorsListener(result_TextField));
    
47.         JButton button9 = new JButton("9");
    
48.         button9.addActionListener(numbersAndOperatorsListener(result_TextField));
    
49.         //计算命令按钮 加减乘除以及小数点等
    
50.         //小数点
    
51.         JButton button_spot = new JButton(".");
    
52.         button_spot.addActionListener(numbersAndOperatorsListener(result_TextField));
    
53.         //加
    
54.         JButton button_add = new JButton("+");
    
55.         button_add.addActionListener(numbersAndOperatorsListener(result_TextField));
    
56.         //减
    
57.         JButton button_subtract = new JButton("-");
    
58.         button_subtract.addActionListener(numbersAndOperatorsListener(result_TextField));
    
59.         //乘
    
60.         JButton button_multiply = new JButton("*");
    
61.         button_multiply.addActionListener(numbersAndOperatorsListener(result_TextField));
    
62.         //除
    
63.         JButton button_divide = new JButton("/");
    
64.         button_divide.addActionListener(numbersAndOperatorsListener(result_TextField));
    
65.         //等于
    
66.         JButton button_equal = new JButton("=");
    
67.         button_equal.addActionListener(equalButtonListener(result_TextField));
    
68.         //创建JPanel面板组件并且采用 BorderLayout布局格式
    
69.         JPanel panel = new JPanel(new BorderLayout());
    
70.         //在面板中添加文本框组件-->靠左
    
71.         panel.add(result_TextField,BorderLayout.WEST);
    
72.         //在面板中添加文本框组件-->靠右
    
73.         panel.add(clear_Button, BorderLayout.EAST);
    
74.         JPanel pan1 = new JPanel(new GridLayout(1,4,5,5));
    
75.         pan1.add(button7);
    
76.         pan1.add(button8);
    
77.         pan1.add(button9);
    
78.         pan1.add(button_divide);
    
79.         JPanel pan2 = new JPanel(new GridLayout(1,4,5,5));
    
80.         pan2.add(button4);
    
81.         pan2.add(button5);
    
82.         pan2.add(button6);
    
83.         pan2.add(button_multiply);
    
84.         JPanel pan3 = new JPanel(new GridLayout(1,4,5,5));
    
85.         pan3.add(button1);
    
86.         pan3.add(button2);
    
87.         pan3.add(button3);
    
88.         pan3.add(button_subtract);
    
89.         JPanel pan4 = new JPanel(new GridLayout(1,4,5,5));
    
90.         pan4.add(button0);
    
91.         pan4.add(button_spot);
    
92.         pan4.add(button_equal);
    
93.         pan4.add(button_add);
    
94.         //在容器上添加面板控件
    
95.         container.add(panel);
    
96.         container.add(pan1);
    
97.         container.add(pan2);
    
98.         container.add(pan3);
    
99.         container.add(pan4);
    
100.         //将容器外部特性实例化
     
101.         setTitle(" Calculator ");
     
102.         //设窗体的大小     宽和高
     
103.         setSize(400,250);
     
104.         //设定窗体的可视化
     
105.         setVisible(true);
     
106.         //设置窗体的关闭方式
     
107.         setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
     
108.     }
     
109.     //数字和运算符监听事件
     
110.     public ActionListener numbersAndOperatorsListener(JTextField result_TextField ){
     
111.         return new ActionListener(){
     
112.             @Override
     
113.             public void actionPerformed(ActionEvent e) {
     
114.                 JButton jButton = (JButton) e.getSource();
     
115.                 System.out.println("获取事件监听器："+jButton.getText());
     
116.                 string += jButton.getText();
     
117.                 result_TextField.setText(string);
     
118.             }
     
119.         };
     
120.     }
     
121.     //使用JDK自带的类可以实现执行字符串中的运算公式的功能
     
122.     static ScriptEngine javaScriptEngine = new ScriptEngineManager().getEngineByName("JavaScript");
     
123.     //等于运算
     
124.     public ActionListener equalButtonListener(JTextField result_TextField){
     
125. 
     
126.         return  new ActionListener() {
     
127.             String str =null;
     
128.             @Override
     
129.             public void actionPerformed(ActionEvent e) {
     
130.                 System.out.println("result_TextField -->"+ result_TextField.getText());
     
131.                 str = result_TextField.getText();
     
132.                 string = equal(str);
     
133.                 result_TextField.setText(string);
     
134.             }
     
135.             public String equal(String str){
     
136.                 String result ="";
     
137.                 try {
     
138.                     System.out.println(javaScriptEngine.eval(str));
     
139.                     result = javaScriptEngine.eval(str).toString();
     
140.                 } catch (Exception t) {
     
141.                 }
     
142.                 return result;
     
143.             }
     
144.         };
     
145.     }
     
146.     //清除文本框的内容
     
147.     public ActionListener clearButtonListener(JTextField result_TextField){
     
148.         return  new ActionListener() {
     
149.             @Override
     
150.             public void actionPerformed(ActionEvent e) {
     
151.                 string = "";
     
152.                 result_TextField.setText(string);
     
153.             }
     
154.         };
     
155.     }
     
156. 
     
157.     public static void main(String[] args) {
     
158.         Calculator calculator = new Calculator();
     
159.     }
     
160. 
     
161. }

复制代码

FishC

卷帘红尘亦爱她 发表于 2024-04-11 15:03
@FishC1通过该代码对你所书写代码进行优化import java ...

import javax.script.ScriptEngine;
import javax.script.ScriptEngineManager;
import javax.swing.*;
import java.awt.*;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;

class Calculator extends JFrame {
    private String expression = "";

    public Calculator() {
        Container container = getContentPane();
        container.setLayout(new GridLayout(5, 1, 50, 10));

        JTextField resultTextField = new JTextField(26);
        resultTextField.setText(expression);

        JButton clearButton = new JButton("    Clear     ");
        clearButton.addActionListener(new ActionListener() {
            @Override
            public void actionPerformed(ActionEvent e) {
                expression = "";
                resultTextField.setText(expression);
            }
        });

        JPanel panel = new JPanel(new BorderLayout());
        panel.add(resultTextField, BorderLayout.WEST);
        panel.add(clearButton, BorderLayout.EAST);

        JPanel numPanel = new JPanel(new GridLayout(1, 4, 5, 5));
        JPanel operatorPanel = new JPanel(new GridLayout(1, 4, 5, 5));

        ActionListener numAndOperatorListener = new ActionListener() {
            @Override
            public void actionPerformed(ActionEvent e) {
                JButton button = (JButton) e.getSource();
                expression += button.getText();
                resultTextField.setText(expression);
            }
        };

        for (int i = 1; i <= 9; i++) {
            JButton numButton = new JButton(Integer.toString(i));
            numButton.addActionListener(numAndOperatorListener);
            numPanel.add(numButton);
        }

        JButton zeroButton = new JButton("0");
        zeroButton.addActionListener(numAndOperatorListener);
        JButton dotButton = new JButton(".");
        dotButton.addActionListener(numAndOperatorListener);
        JButton equalButton = new JButton("=");
        equalButton.addActionListener(new ActionListener() {
            @Override
            public void actionPerformed(ActionEvent e) {
                ScriptEngine scriptEngine = new ScriptEngineManager().getEngineByName("JavaScript");
                try {
                    Object result = scriptEngine.eval(expression);
                    expression = result.toString();
                    resultTextField.setText(expression);
                } catch (Exception ex) {
                    expression = "";
                    resultTextField.setText("Error");
                }
            }
        });
        JButton addButton = new JButton("+");
        addButton.addActionListener(numAndOperatorListener);
        JButton subtractButton = new JButton("-");
        subtractButton.addActionListener(numAndOperatorListener);
        JButton multiplyButton = new JButton("*");
        multiplyButton.addActionListener(numAndOperatorListener);
        JButton divideButton = new JButton("/");
        divideButton.addActionListener(numAndOperatorListener);

        operatorPanel.add(zeroButton);
        operatorPanel.add(dotButton);
        operatorPanel.add(equalButton);
        operatorPanel.add(addButton);
        operatorPanel.add(subtractButton);
        operatorPanel.add(multiplyButton);
        operatorPanel.add(divideButton);

        container.add(panel);
        container.add(numPanel);
        container.add(operatorPanel);

        setTitle("Calculator");
        setSize(400, 250);
        setVisible(true);
        setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
    }

    public static void main(String[] args) {
        SwingUtilities.invokeLater(() -> new Calculator());
    }
}

以上回复来自 FishC AI 小助理，如未能正确解答您的问题，请继续追问。

卷帘红尘亦爱她

@FishC1对你所写代码进行修改将下方按钮改为四行