简易计算器-课后程序(JAVA基础案例教程-黑马程序员编著-第十一章-课后作业)

【案例11-2】 简易计算器

【案例介绍】

1.案例描述

本案例要求利用Java Swing 图形组件开发一个可以进行简单的四则运算的图形化计算器。

2.运行结果

运行结果

【案例分析】

要制作一个计算器，首先要知道它由哪些部分组成，如下图所示：

一个简单的图形化界面计算器，需要由界面组件、组件的时间监听器和具体的事件处理逻辑组成。

实现一个简易图形化界面计算器可分以下几个步骤：

1.UI组件创建和初始化：包括窗体的创建，显示计算结果文本框、清除按钮、数字按钮、运算符等按钮的初始化。

2.在窗体中添加UI组件：包括放置数字键及运算符面板、放置清除框面板。

3.布局结束之后，就是计算器的难点：编写事件处理程序。

4.按键的响应实现。

5.计算逻辑的实现。

6.注册监听器

【案例实现】

Calculator.java

1. package chapter1102;
2. import java.awt.*;
3. import java.awt.event.*;
4. import javax.swing.*;
5. import java.util.Vector;
6. import java.math.BigDecimal;
7. public class Calculator {
8.           // 操作数1，为了程序的安全，初值一定设置，这里我们设置为0。
9.           String str1 = "0";
10.          // 操作数2
11.      String str2 = "0";
12.      // 运算符
13.     String signal = "+";  
14.      // 运算结果
15.     String result = "";
16.      // 以下k1至k5为状态开关
17.      // 开关1用于选择输入方向，将要写入str1或str2
18.      // 为 1 时写入 str1，为 2 时写入 str2
19.     int k1 = 1;
20.     // 开关 2 用于记录符号键的次数
21.      // 如果 k2>1 说明进行的是 2+3-9+8 这样的多符号运算
22.     int k2 = 1;
23.      // 开关3用于标识 str1 是否可以被清 0
24.      // 等于 1 时可以，不等于1时不能被清0
25.     int k3 = 1;
26.      // 开关4用于标识 str2 是否可以被清 0
27.      // 等于 1 时可以，不等于1时不能被清0
28.     int k4 = 1;
29.      // 开关5用于控制小数点可否被录入
30.      // 等于1时可以，不为1时，输入的小数点被丢掉
31.     int k5 = 1;
32.      // store的作用类似于寄存器，用于记录是否连续按下符号键
33.     JButton store;
34.      //vt 存储之前输入的运算符。
35.     @SuppressWarnings("rawtypes")
36.     Vector vt = new Vector(20, 10);
37.      // 创建一个 JFrame 对象并初始化。JFrame 可以理解为程序的主窗体。  
38.      JFrame frame = new JFrame("Calculator");
39.  //创建一个JTextField对象并初始化。JTextField用于显示操作和计算结果的文本框。
40.      // 参数 20 表明可以显示 20 列的文本内容
41.     JTextField result_TextField = new JTextField(result, 20);
42.      // 清除按钮
43.     JButton clear_Button = new JButton("Clear");
44.      // 数字键0到9
45.     JButton button0 = new JButton("0");
46.     JButton button1 = new JButton("1");
47.     JButton button2 = new JButton("2");
48.     JButton button3 = new JButton("3");
49.     JButton button4 = new JButton("4");
50.     JButton button5 = new JButton("5");
51.     JButton button6 = new JButton("6");
52.     JButton button7 = new JButton("7");
53.     JButton button8 = new JButton("8");
54.     JButton button9 = new JButton("9");
55.      // 计算命令按钮，加减乘除以及小数点等
56.     JButton button_Dian = new JButton(".");
57.     JButton button_jia = new JButton("+");
58.     JButton button_jian = new JButton("-");
59.     JButton button_cheng = new JButton("*");
60.     JButton button_chu = new JButton("/");
61.     JButton button_dy = new JButton("=");
62.     public Calculator() {
63.         button0.setMnemonic(KeyEvent.VK_0);
64.     result_TextField.setHorizontalAlignment(JTextField.RIGHT);
65.         // 创建一个 Jpanel 对象并初始化
66.          JPanel pan = new JPanel();
67.          // 设置该容器的布局为四行四列，边距为5像素
68.         pan.setLayout(new GridLayout(4, 4, 5, 5));
69.          // 将用于计算的按钮添加到容器内
70.         pan.add(button7);
71.         pan.add(button8);
72.         pan.add(button9);
73.         pan.add(button_chu);
74.         pan.add(button4);
75.         pan.add(button5);
76.         pan.add(button6);
77.         pan.add(button_cheng);
78.         pan.add(button1);
79.         pan.add(button2);
80.         pan.add(button3);
81.         pan.add(button_jian);
82.         pan.add(button0);
83.         pan.add(button_Dian);
84.         pan.add(button_dy);
85.         pan.add(button_jia);
86.          // 设置 pan 对象的边距
87.         pan.setBorder(BorderFactory.createEmptyBorder(5, 5, 5, 5));
88.          // 按照同样的方式设置第二个JPanel
89.         JPanel pan2 = new JPanel();
90.         pan2.setLayout(new BorderLayout());
91.         pan2.add(result_TextField, BorderLayout.WEST);
92.         pan2.add(clear_Button, BorderLayout.EAST);
93.           // 设置主窗口出现在屏幕上的位置
94.         frame.setLocation(300, 200);
95.          // 设置窗体可以调大小
96.         frame.setResizable(true);
97.          //窗体中可以放置 JPanel，这里我们将面板pan和面板pan2让如窗体
98.         frame.getContentPane().setLayout(new BorderLayout());
99.         frame.getContentPane().add(pan2, BorderLayout.NORTH);
100.         frame.getContentPane().add(pan, BorderLayout.CENTER);
101.         frame.pack();
102.         frame.setVisible(true);
103.          //Listener类中编写的是数字键的响应逻辑。
104.         class Listener implements ActionListener {
105.            @SuppressWarnings("unchecked")
106.            public void actionPerformed(ActionEvent e) {
107.                String ss = ((JButton) e.getSource()).getText();
108.                store = (JButton) e.getSource();
109.                vt.add(store);
110.                if (k1 == 1) {
111.                    if (k3 == 1) {
112.                        str1 = "";
113.                        k5 = 1;
114.                    }
115.                    str1 = str1 + ss;
116.                    k3 = k3 + 1;
117.                    result_TextField.setText(str1);
118.                } else if (k1 == 2) {
119.                    if (k4 == 1) {
120.                        str2 = "";
121.                        k5 = 1;
122.                }
123.                    str2 = str2 + ss;
124.                    k4 = k4 + 1;
125.                    result_TextField.setText(str2);
126.                }                              
127.            }
128.         }
129.           //Listener_signal类中编写了运算符号键的响应逻辑
130.         class Listener_signal implements ActionListener {
131.            @SuppressWarnings("unchecked")
132.            public void actionPerformed(ActionEvent e) {
133.                String ss2 = ((JButton) e.getSource()).getText();
134.                store = (JButton) e.getSource();
135.                vt.add(store);
136.                if (k2 == 1) {
137.                    k1 = 2;
138.                    k5 = 1;
139.                    signal = ss2;
140.                    k2 = k2 + 1;
141.                } else {
142.                    int a = vt.size();
143.                    JButton c = (JButton) vt.get(a - 2);
144.                    if (!(c.getText().equals("+"))
145.                            && !(c.getText().equals("-"))
146.                            && !(c.getText().equals("*"))
147.                            && !(c.getText().equals("/")))
148.                    {
149.                        cal();
150.                        str1 = result;
151.                        k1 = 2;
152.                        k5 = 1;
153.                        k4 = 1;
154.                        signal = ss2;
155.                    }
156.                    k2 = k2 + 1;
157.                }
158.            }
159.         }
160.      //Listener_clear类中编写了清除键的响应逻辑
161.     class Listener_clear implements ActionListener {
162.            @SuppressWarnings("unchecked")
163.            public void actionPerformed(ActionEvent e) {
164.                store = (JButton) e.getSource();
165.                vt.add(store);
166.                k5 = 1;
167.                k2 = 1;
168.                k1 = 1;
169.                k3 = 1;
170.                k4 = 1;
171.                str1 = "0";
172.                str2 = "0";
173.                signal = "";
174.                result = "";
175.                result_TextField.setText(result);
176.                vt.clear();
177.            }
178.         }
179.      //Listener_dy类中编写的是等于号键的响应逻辑
180.     class Listener_dy implements ActionListener {
181.            @SuppressWarnings("unchecked")
182.            public void actionPerformed(ActionEvent e) {
183.                store = (JButton) e.getSource();
184.                vt.add(store);
185.                cal();
186.                k1 = 1;
187.                k2 = 1;
188.                k3 = 1;
189.                k4 = 1;
190.                str1 = result;
191.            }
192.         }
193. //Listener_xiaos类中编写的是小数点键的相应逻辑
194. class Listener_xiaos implements ActionListener {
195.            @SuppressWarnings("unchecked")
196.            public void actionPerformed(ActionEvent e) {
197.                store = (JButton) e.getSource();
198.                vt.add(store);
199.                if (k5 == 1) {
200.                    String ss2 = ((JButton) e.getSource()).getText();
201.                    if (k1 == 1) {
202.                        if (k3 == 1) {
203.                            str1 = "";
204.                            k5 = 1;
205.                        }
206.                        str1 = str1 + ss2;
207.                        k3 = k3 + 1;
208.                        result_TextField.setText(str1);
209.                    } else if (k1 == 2) {
210.                        if (k4 == 1) {
211.                            str2 = "";
212.                            k5 = 1;
213.                        }
214.                        str2 = str2 + ss2;
215.                        k4 = k4 + 1;
216.                        result_TextField.setText(str2);
217.                    }
218.                }
219.                k5 = k5 + 1;
220.            }
221.         }
222.           // 监听等于键
223.         Listener_dy jt_dy = new Listener_dy();
224.          // 监听数字键
225.         Listener jt = new Listener();
226.          // 监听符号键
227.         Listener_signal jt_signal = new Listener_signal();
228.          // 监听清除键
229.         Listener_clear jt_c = new Listener_clear();
230.          // 监听小数点键
231.         Listener_xiaos jt_xs = new Listener_xiaos();
232.         button7.addActionListener(jt);
233.         button8.addActionListener(jt);
234.         button9.addActionListener(jt);
235.         button_chu.addActionListener(jt_signal);
236.         button4.addActionListener(jt);
237.         button5.addActionListener(jt);
238.         button6.addActionListener(jt);
239.         button_cheng.addActionListener(jt_signal);
240.         button1.addActionListener(jt);
241.         button2.addActionListener(jt);
242.         button3.addActionListener(jt);
243.         button_jian.addActionListener(jt_signal);
244.         button0.addActionListener(jt);
245.         button_Dian.addActionListener(jt_xs);
246.         button_dy.addActionListener(jt_dy);
247.         button_jia.addActionListener(jt_signal);
248.         clear_Button.addActionListener(jt_c);
249.           // 窗体关闭事件的响应程序
250.         frame.addWindowListener(new WindowAdapter() {
251.            public void windowClosing(WindowEvent e) {
252.                System.exit(0);
253.            }
254.         });
255.     }
256.      // calc()方法中编写了计算逻辑的实现。
257.     public void cal() {
258.         double a2;
259.         double b2;
260.         String c = signal;
261.         double result2 = 0;
262.         if (c.equals("")) {
263.            result_TextField.setText("Please input operator");
264.         } else {
265.            if (str1.equals("."))
266.                str1 = "0.0";
267.            if (str2.equals("."))
268.                str2 = "0.0";
269.            a2 = Double.valueOf(str1).doubleValue();
270.            b2 = Double.valueOf(str2).doubleValue();
271.            if (c.equals("+")) {
272.                result2 = a2 + b2;
273.            }
274.            if (c.equals("-")) {
275.                result2 = a2 - b2;
276.            }
277.            if (c.equals("*")) {
278.                BigDecimal m1 = new BigDecimal(Double.toString(a2));
279.                    BigDecimal m2 = new
280.                                     BigDecimal(Double.toString(b2));
281.                    result2 = m1.multiply(m2).doubleValue();
282.            }
283.            if (c.equals("/")) {
284.                if (b2 == 0) {
285.                    result2 = 0;
286.                } else {
287.                    result2 = a2 / b2;
288.                }
289.            }
290.            result = ((new Double(result2)).toString());
291.            result_TextField.setText(result);
292.         }
293.     }
294.     @SuppressWarnings("unused")
295.     public static void main(String[] args) {
296.     try {  
297.  //通过 UIManager 来设置窗体的 UI 风格
298.  UIManager.setLookAndFeel("javax.swing.plaf.metal.MetalLookAndFeel");
299.         } catch (Exception e) {
300.            e.printStackTrace();
301.         }
302.         Calculator cal = new Calculator();
303.     }
304. }

上述代码中，第7-32行代码，定义了一些成员变量，方便响应的逻辑实现。第34-35行代码，创建了一个Vector对象，存储之前输入的运算符。第37行代码，创建了一个 JFrame 对象并初始化。JFrame 可以理解为程序的主窗体。第40行代码，创建了一个JTextField对象并初始化。JTextField用于显示操作和计算结果的文本框。参数 20 表明可以显示 20 列的文本内容。第42行代码，创建了一个清除按钮对象。第44-53行，创建数字键0-9按钮对象。第55-60行，创建计算命令按钮，加减乘除以及小数点等按钮对象。第65-101行代码，是对计算器进行布局。Listener类中编写的是数字键的响应逻辑。Listener_xiaos类中编写的是小数点键的相应逻辑。Listener_signal类中编写了运算符号键的响应逻辑。Listener_dy类中编写的是等于号键的响应逻辑。Listener_clear类中编写了清除键的响应逻辑。calc()方法中编写了计算逻辑的实现。第222-247行代码，创建监听对象，斌对各个按键进行监听。第249-253行代码，为窗体关闭事件的响应程序。第297行代码，通过 UIManager 来设置窗体的 UI 风格。文章来源地址https://www.toymoban.com/news/detail-778858.html

到了这里，关于简易计算器-课后程序(JAVA基础案例教程-黑马程序员编著-第十一章-课后作业)的文章就介绍完了。如果您还想了解更多内容，请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章，希望大家以后多多支持TOY模板网！