zoukankan html css js c++ java

“四则运算练习器”的开发心得与优化方案

软件工程综合实践专题第二次作业

注：本博客与徐明煜同学一同合作完成。（1759204 徐明煜 1759213 孙子璇）

一、概述

这次我们要做的是一个四则运算练习器，要求如下：

1. 每次出300道四则运算练习题，两个运算符，100以内的数字，题目避免重复；

2. 写出答案，并保证答案在0-100之间；

3. 可扩展性；

4. 可定制（题目数量是否可变，打印方式是否可以选择，有无乘除法，有无括号，数值范围，加减有无负数，除法有无余数，是否支持分数，打印中每行的间隔是否可调整）；

5. 代码规范；

除基本要求外，我们认为GUI对于一个四则运算练习器来讲也是必要的，因此，在综合考虑开发周期的限制与当前的学习情况后，我们最终选择使用JAVA语言来实现。

二、功能实现

1. 根据自身需求对“+”、“−”、“×”、“÷”进行自主选择

可以自主选择需要练习的运算类型（+/−/×/÷）。

亮点：实现了针对题型的个性化设计。

通过该应用用户可进行对四则运算的专项训练（每次勾选一个）及混合训练（每次勾选两个以上），且可以根据个人练习需要对题型进行任意组合，以达到巩固强项、强化弱项的目的。

2. 随机生成300道不重复的练习题

根据用户的选择生成对应的一级运算（加法、减法）及二级运算（乘法、除法）题目共300道（包括结果为负数的减法运算，及结果取整数位的除法运算），且能够让用户在应用中进行作答。

亮点：能够随机生成参加运算的数字及运算符。

利用产生随机数（100以内）的方法来避免题目重复的问题。当用户选择对两种或以上运算进行练习时，系统将随机显示相应的运算符，以实现应用的可定制化。

3. 检验答案的正确性

在用户完成练习并“确定”后，系统会将用户的答案与正确答案相比对，来判断用户输入的答案是否正确，并将结果显示在整道题目末端——正确（绿色）⁄ 错误（红色）。

亮点：能够主动判断答案正误。

这一功能省去了做完练习后的人工批阅环节，减轻了批阅者的负担；用不同的颜色区分正误能够让用户更加直观地了解自己的做题情况，方便用户根据现有的掌握情况来制定下一步的练习计划。

三、问题与解决办法

1. 如何生成GUI？

我们利用Java swing实现对GUI的开发，参考

（1）“Java Swing 图形界面开发简介”

原址：http://blog.csdn.net/xietansheng/article/details/72814531

（2）“JavaSwing_1.7: BorderLayout（边界布局）”

原址：http://blog.csdn.net/xietansheng/article/details/72862707

（3）“JavaSwing_1.9: null（绝对布局）”

原址：http://blog.csdn.net/xietansheng/article/details/72862726

（4）“JavaSwing_2.1: JLabel（标签）”

原址：http://blog.csdn.net/xietansheng/article/details/74362076

（5）“JavaSwing_2.2: JButton（按钮）”

原址：http://blog.csdn.net/xietansheng/article/details/74363221

（6）“JavaSwing_2.4: JCheckBox（复选框）”

原址：http://blog.csdn.net/xietansheng/article/details/74363460

（7）“JavaSwing_2.6: JTextField（文本框）”

原址：http://blog.csdn.net/xietansheng/article/details/74363582

（8）“JavaSwing_2.10: JList（列表框）”

原址：http://blog.csdn.net/xietansheng/article/details/74363719

（9）“JavaSwing_3.1: JPanel（面板）”

原址：http://blog.csdn.net/xietansheng/article/details/74366470

（10）“JavaSwing_3.2: JScrollPane（滚动面板）”

原址：http://blog.csdn.net/xietansheng/article/details/74366495

（11）“JavaSwing_4.1: JFrame（窗口）”

原址：http://blog.csdn.net/xietansheng/article/details/75948927

（12）“JavaSwing_5.1: 组件的位置和尺寸”

原址：http://blog.csdn.net/xietansheng/article/details/78389183

（13）“JavaSwing_5.3: 事件处理”

原址：http://blog.csdn.net/xietansheng/article/details/78389255

该应用总体上共分为两个图形界面，一个是用户进行题型选择的界面，另一个是用户进行练习的界面。

其中因为JScrollPane中只可添加一个组件，故将所需组件添加在JPanel中后，又将JPanel添加在JScrollPane中。

2. 如何避免题目重复性？

要避免题目的重复性，就要实现数字（参与运算的）的随机性，又因为要求中对数值范围（100以内）进行了限制，因此我们参考了

“How do I generate random integers within a specific range in Java?”

原址：http://stackoverflow.com/questions/363681/generating-random-integers-in-a-range-with-java

3. 如何实现个性化？

个性化即可定制化，即应用可根据用户的选择随机产生题目。

这一功能的实现主要依赖于运算符的随机产生：通过设置全局变量flag标识复选框的选择情况，并用整型变量代表其所对应的运算符，再根据复选框的选择个数，随机生成整形变量的值。

 1        else if(Listener.flag1&&Listener.flag2&&Listener.flag3&&Listener.flag4) {
 2                     for(int i=0;i<300;i++) {
 3                         Random random = new Random();
 4                         Integer s = random.nextInt(4);
 5                         if(s==0) {
 6                             sign[i] = "+";
 7                         } else if(s==1) {
 8                             sign[i] = "-";
 9                         } else if(s==2) {
10                             sign[i] = "*";
11                         } else if(s==3) {
12                             sign[i] = "/";
13                         }
14             }
15         }

4. 如何判断正误？

在生成随机数的同时将其存入数组：先将运算符前的数字存入a[ ]，运算符后的数字存入b[ ]，再将运算结果存入c[ ]。最后用for循环在用户输入答案后将输入的内容与c[ i ]相比较。

当二者相等时为“正确”，否则为错误。

 1     Integer[] answer;
 2     public void setjTextFields(JTextField[] jTextFields) {
 3         for(int i=0;i<300;i++) {
 4             this.jTextFields[i] = jTextFields[i];
 5         }
 6     }
 7     public void setAnswer(Integer[] answer) {
 8         this.answer = answer;
 9     }
10     public void actionPerformed(ActionEvent e) {
11             for(int i=0;i<300;i++) {
12             if(Integer.toString(answer1[i]).equals(jTextFields[i].getText())) {
13                 jLabels[i].setText("正确");
14                 jLabels[i].setForeground(Color.green);
15             } else {
16                 jLabels[i].setText("错误");
17                 jLabels[i].setForeground(Color.red);
18             }
19             System.out.println(Integer.toString(answer1[i])+" "+jTextFields[i].getText()+"*");
20         }

产生随机数并将其存入数组：

 1         Random random = new Random();
 2         int count = 0;
 3         while (count < a.length) {
 4             Boolean flag = true;
 5             Integer r = random.nextInt(100);     //生成100以内的随机数
 6             for (int i = 0; i < a.length; i++) {
 7                 if (r == a[i]) {
 8                     flag = false;
 9                     break;
10                 }
11             }
12             if (flag) {
13                 a[count] = r;
14                 System.out.println(a[count]);
15                 count++;
16             }
17         }

四、源代码

CalculateWindow.java

  1 import javax.swing.*;
  2 import java.awt.*;
  3 import java.util.Random;
  4 
  5 public class CalculateWindow extends JFrame{
  6     JPanel jPaneL;
  7 
  8     JList <Integer> jList1;
  9     JList <String> jList2;
 10     JList <Integer> jList3;
 11     JList <String> jList4;
 12 
 13     JList <Integer> jList5;
 14     JList <String> jList6;
 15     JList <Integer> jList7;
 16     JList <String> jList8;
 17 
 18     JList <Integer> jList9;
 19     JList <String> jList10;
 20     JList <Integer> jList11;
 21     JList <String> jList12;
 22 
 23     JList <Integer> jList13;
 24     JList <String> jList14;
 25     JList <Integer> jList15;
 26     JList <String> jList16;
 27 
 28     JTextField[] jTextFields=new JTextField[300];
 29     JLabel[] jLabels=new JLabel[300];
 30 
 31     JButton jButton1;
 32     CalculateListener calculateListener=new CalculateListener();
 33 
 34     private Integer[] a = new Integer[75];
 35     private Integer[] b = new Integer[75];
 36     private Integer[] c = new Integer[75];
 37     private Integer[] d = new Integer[75];
 38     private Integer[] e = new Integer[75];
 39     private Integer[] f = new Integer[75];
 40     private Integer[] g = new Integer[75];
 41     private Integer[] h = new Integer[75];
 42 
 43     private Integer[] answer1 = new Integer[75];
 44     private Integer[] answer2 = new Integer[75];
 45     private Integer[] answer3 = new Integer[75];
 46     private Integer[] answer4 = new Integer[75];
 47 
 48     private String[] sign=new String[75];
 49     private String[] equal=new String[75];
 50 
 51     void create() {
 52         JFrame jf = new JFrame("四则运算练习器");
 53         jf.setLayout(null);
 54         jf.setSize(1700, 1025);
 55         jf.setLocationRelativeTo(null);
 56         jf.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
 57 
 58         jPaneL=new JPanel();
 59         jPaneL.setLayout(null);
 60 
 61         Random random1 = new Random();
 62         int count1 = 0;
 63         while (count1 < a.length) {
 64             Boolean flag1 = true;
 65             Integer r1 = random1.nextInt(100);     //生成100以内的随机数
 66             for (int i = 0; i < a.length; i++) {
 67                 if (r1 == a[i]) {
 68                     flag1 = false;
 69                     break;
 70                 }
 71             }
 72             if (flag1) {
 73                 a[count1] = r1;
 74                 System.out.println(a[count1]);
 75                 count1++;
 76             }
 77         }
 78 
 79         Random random2 = new Random();
 80         int count2 = 0;
 81         while (count2 < b.length) {
 82             Boolean flag2 = true;
 83             Integer r2 = random2.nextInt(100);     //生成100以内的随机数
 84             for (int i = 0; i < b.length; i++) {
 85                 if (r2 == b[i]||(Listener.flag4 && r2==0)) {
 86                     flag2 = false;
 87                     break;
 88                 }
 89             }
 90             if (flag2) {
 91                 b[count2] = r2;
 92                 System.out.println(r2);
 93                 count2++;
 94             }
 95         }
 96 
 97         Random random3 = new Random();
 98         int count3 = 0;
 99         while (count3 < c.length) {
100             Boolean flag3 = true;
101             Integer r3 = random3.nextInt(100);     //生成100以内的随机数
102             for (int i = 0; i < c.length; i++) {
103                 if (r3 == c[i]) {
104                     flag3 = false;
105                     break;
106                 }
107             }
108             if (flag3) {
109                 c[count3] = r3;
110                 System.out.println(r3);
111                 count3++;
112             }
113         }
114 
115         Random random4 = new Random();
116         int count4 = 0;
117         while (count4 < d.length) {
118             Boolean flag4 = true;
119             Integer r4 = random4.nextInt(100);     //生成100以内的随机数
120             for (int i = 0; i < d.length; i++) {
121                 if (r4 == d[i]||(Listener.flag4 && r4==0)) {
122                     flag4 = false;
123                     break;
124                 }
125             }
126             if (flag4) {
127                 d[count4] = r4;
128                 System.out.println(r4);
129                 count4++;
130             }
131         }
132 
133         Random random5 = new Random();
134         int count5 = 0;
135         while (count5 < e.length) {
136             Boolean flag5 = true;
137             Integer r5 = random5.nextInt(100);     //生成100以内的随机数
138             for (int i = 0; i < e.length; i++) {
139                 if (r5 == e[i]) {
140                     flag5 = false;
141                     break;
142                 }
143             }
144             if (flag5) {
145                 e[count5] = r5;
146                 System.out.println(r5);
147                 count5++;
148             }
149         }
150 
151         Random random6 = new Random();
152         int count6 = 0;
153         while (count6 < f.length) {
154             Boolean flag6 = true;
155             Integer r6 = random6.nextInt(100);     //生成100以内的随机数
156             for (int i = 0; i < f.length; i++) {
157                 if (r6 == f[i]||(Listener.flag4 && r6==0)) {
158                     flag6 = false;
159                     break;
160                 }
161             }
162             if (flag6) {
163                 f[count6] = r6;
164                 System.out.println(r6);
165                 count6++;
166             }
167         }
168 
169         Random random7 = new Random();
170         int count7 = 0;
171         while (count7 < g.length) {
172             Boolean flag7 = true;
173             Integer r7 = random7.nextInt(100);     //生成100以内的随机数
174             for (int i = 0; i < g.length; i++) {
175                 if (r7 == g[i]) {
176                     flag7 = false;
177                     break;
178                 }
179             }
180             if (flag7) {
181                 g[count7] = r7;
182                 System.out.println(r7);
183                 count7++;
184             }
185         }
186 
187         Random random8 = new Random();
188         int count8 = 0;
189         while (count8 < h.length) {
190             Boolean flag8 = true;
191             Integer r8 = random8.nextInt(100);     //生成100以内的随机数
192             for (int i = 0; i < h.length; i++) {
193                 if (r8 == h[i]||(Listener.flag4 && r8==0)) {
194                     flag8 = false;
195                     break;
196                 }
197             }
198             if (flag8) {
199                 h[count8] = r8;
200                 System.out.println(r8);
201                 count8++;
202             }
203         }
204 
205         if(Listener.flag1&&!Listener.flag2&&!Listener.flag3&&!Listener.flag4) {
206             for(int i=0;i<75;i++)
207                 sign[i]="+";
208         } else if(Listener.flag2&&!Listener.flag1&&!Listener.flag3&&!Listener.flag4) {
209             for(int i=0;i<75;i++)
210                 sign[i]="-";
211         } else if(Listener.flag3&&!Listener.flag1&&!Listener.flag2&&!Listener.flag4) {
212             for(int i=0;i<75;i++)
213                 sign[i]="*";
214         } else if(Listener.flag4&&!Listener.flag1&&!Listener.flag2&&!Listener.flag3) {
215             for(int i=0;i<75;i++)
216                 sign[i]="/";
217         } else if(Listener.flag1&&Listener.flag2&&!Listener.flag3&&!Listener.flag4) {
218             for(int i=0;i<75;i++) {
219                 Integer s = random1.nextInt(2);
220                 if(s==0) {
221                     sign[i] = "+";
222                 } else if(s==1) {
223                     sign[i] = "-";
224                 }
225             }
226         } else if(Listener.flag1&&Listener.flag3&&!Listener.flag2&&!Listener.flag4) {
227             for(int i=0;i<75;i++) {
228                 Random random = new Random();
229                 Integer s = random.nextInt(2);
230                 if(s==0) {
231                     sign[i] = "+";
232                 } else if(s==1) {
233                     sign[i] = "*";
234                 }
235             }
236         } else if(Listener.flag1&&Listener.flag4&&!Listener.flag2&&!Listener.flag3) {
237             for(int i=0;i<75;i++) {
238                 Random random = new Random();
239                 Integer s = random.nextInt(2);
240                 if(s==0) {
241                     sign[i] = "+";
242                 } else if(s==1) {
243                     sign[i] = "/";
244                 }
245             }
246         } else if(Listener.flag2&&Listener.flag3&&!Listener.flag1&&!Listener.flag4) {
247             for(int i=0;i<75;i++) {
248                 Random random = new Random();
249                 Integer s = random.nextInt(2);
250                 if(s==0) {
251                     sign[i] = "-";
252                 } else if(s==1) {
253                     sign[i] = "*";
254                 }
255             }
256         } else if(Listener.flag2&&Listener.flag4&&!Listener.flag3&&!Listener.flag1) {
257             for(int i=0;i<75;i++) {
258                 Random random = new Random();
259                 Integer s = random.nextInt(2);
260                 if(s==0) {
261                     sign[i] = "-";
262                 } else if(s==1) {
263                     sign[i] = "/";
264                 }
265             }
266         } else if(Listener.flag3&&Listener.flag4&&!Listener.flag1&&!Listener.flag2) {
267             for(int i=0;i<75;i++) {
268                 Random random = new Random();
269                 Integer s = random.nextInt(2);
270                 if(s==0) {
271                     sign[i] = "*";
272                 } else if(s==1) {
273                     sign[i] = "/";
274                 }
275             }
276         } else if(Listener.flag1&&Listener.flag2&&Listener.flag3&&!Listener.flag4) {
277             for(int i=0;i<75;i++) {
278                 Random random = new Random();
279                 Integer s = random.nextInt(3);
280                 if(s==0) {
281                     sign[i] = "+";
282                 } else if(s==1) {
283                     sign[i] = "-";
284                 } else if(s==2) {
285                     sign[i] = "*";
286                 }
287             }
288         } else if(Listener.flag1&&Listener.flag3&&Listener.flag4&&!Listener.flag2) {
289             for(int i=0;i<75;i++) {
290                 Random random = new Random();
291                 Integer s = random.nextInt(3);
292                 if(s==0) {
293                     sign[i] = "+";
294                 } else if(s==1) {
295                     sign[i] = "*";
296                 } else if(s==2) {
297                     sign[i] = "/";
298                 }
299             }
300         } else if(Listener.flag2&&Listener.flag3&&Listener.flag4&&!Listener.flag1) {
301             for(int i=0;i<75;i++) {
302                 Random random = new Random();
303                 Integer s = random.nextInt(3);
304                 if(s==0) {
305                     sign[i] = "-";
306                 } else if(s==1) {
307                     sign[i] = "*";
308                 } else if(s==2) {
309                     sign[i] = "/";
310                 }
311             }
312         } else if(Listener.flag1&&Listener.flag2&&Listener.flag3&&Listener.flag4) {
313             for(int i=0;i<75;i++) {
314                 Random random = new Random();
315                 Integer s = random.nextInt(4);
316                 if(s==0) {
317                     sign[i] = "+";
318                 } else if(s==1) {
319                     sign[i] = "-";
320                 } else if(s==2) {
321                     sign[i] = "*";
322                 }
323                 else if(s==3) {
324                     sign[i] = "/";
325                 }
326             }
327         }
328 
329         for(int i=0;i<75;i++) {
330             equal[i] = "=";
331         }
332 
333         for(int k=0;k<75;k++) {
334             if(sign[k].equals("+")) {
335                 answer1[k]=a[k]+b[k];
336                 answer2[k]=c[k]+d[k];
337                 answer3[k]=e[k]+f[k];
338                 answer4[k]=g[k]+h[k];
339             } else if(sign[k].equals("-")) {
340                 answer1[k]=a[k]-b[k];
341                 answer2[k]=c[k]-d[k];
342                 answer3[k]=e[k]-f[k];
343                 answer4[k]=g[k]-h[k];
344             } else if(sign[k].equals("*")) {
345                 answer1[k]=a[k]*b[k];
346                 answer2[k]=c[k]*d[k];
347                 answer3[k]=e[k]*f[k];
348                 answer4[k]=g[k]*h[k];
349             } else if(sign[k].equals("/")) {
350                 answer1[k]=a[k]/b[k];
351                 answer2[k]=c[k]/d[k];
352                 answer3[k]=e[k]/f[k];
353                 answer4[k]=g[k]/h[k];
354             }
355         }
356 
357         jList1=new JList<Integer>(a);
358         jList2=new JList<String>(sign);
359         jList3=new JList<Integer>(b);
360         jList4=new JList<String>(equal);
361 
362         jList5=new JList<Integer>(c);
363         jList6=new JList<String>(sign);
364         jList7=new JList<Integer>(d);
365         jList8=new JList<String>(equal);
366 
367         jList9=new JList<Integer>(e);
368         jList10=new JList<String>(sign);
369         jList11=new JList<Integer>(f);
370         jList12=new JList<String>(equal);
371 
372         jList13=new JList<Integer>(g);
373         jList14=new JList<String>(sign);
374         jList15=new JList<Integer>(h);
375         jList16=new JList<String>(equal);
376 
377         jList1.setBounds(0, 0, 50, 2925);
378         jList1.setFont(new Font("宋体", Font.PLAIN, 32));
379         jList2.setBounds(50, 0, 50, 2925);
380         jList2.setFont(new Font("宋体", Font.PLAIN, 32));
381         jList3.setBounds(100, 0, 50, 2925);
382         jList3.setFont(new Font("宋体", Font.PLAIN, 32));
383         jList4.setBounds(150, 0, 50, 2925);
384         jList4.setFont(new Font("宋体", Font.PLAIN, 32));
385 
386         jList5.setBounds(400, 0, 50, 2925);
387         jList5.setFont(new Font("宋体", Font.PLAIN, 32));
388         jList6.setBounds(450, 0, 50, 2925);
389         jList6.setFont(new Font("宋体", Font.PLAIN, 32));
390         jList7.setBounds(500, 0, 50, 2925);
391         jList7.setFont(new Font("宋体", Font.PLAIN, 32));
392         jList8.setBounds(550, 0, 50, 2925);
393         jList8.setFont(new Font("宋体", Font.PLAIN, 32));
394 
395         jList9.setBounds(800, 0, 50, 2925);
396         jList9.setFont(new Font("宋体", Font.PLAIN, 32));
397         jList10.setBounds(850, 0, 50, 2925);
398         jList10.setFont(new Font("宋体", Font.PLAIN, 32));
399         jList11.setBounds(900, 0, 50, 2925);
400         jList11.setFont(new Font("宋体", Font.PLAIN, 32));
401         jList12.setBounds(950, 0, 50, 2925);
402         jList12.setFont(new Font("宋体", Font.PLAIN, 32));
403 
404         jList13.setBounds(1200, 0, 50, 2925);
405         jList13.setFont(new Font("宋体", Font.PLAIN, 32));
406         jList14.setBounds(1250, 0, 50, 2925);
407         jList14.setFont(new Font("宋体", Font.PLAIN, 32));
408         jList15.setBounds(1300, 0, 50, 2925);
409         jList15.setFont(new Font("宋体", Font.PLAIN, 32));
410         jList16.setBounds(1350, 0, 50, 2925);
411         jList16.setFont(new Font("宋体", Font.PLAIN, 32));
412 
413         jPaneL.add(jList1);
414         jPaneL.add(jList2);
415         jPaneL.add(jList3);
416         jPaneL.add(jList4);
417         jPaneL.add(jList5);
418         jPaneL.add(jList6);
419         jPaneL.add(jList7);
420         jPaneL.add(jList8);
421         jPaneL.add(jList9);
422         jPaneL.add(jList10);
423         jPaneL.add(jList11);
424         jPaneL.add(jList12);
425         jPaneL.add(jList13);
426         jPaneL.add(jList14);
427         jPaneL.add(jList15);
428         jPaneL.add(jList16);
429 
430         for(int n=0;n<75;n++) {
431             jTextFields[n]=new JTextField();
432             jTextFields[n].setBounds(200, n*39, 50, 39);
433             jTextFields[n].setFont(new Font("宋体", Font.PLAIN, 32));
434             jPaneL.add(jTextFields[n]);
435 
436             jLabels[n]=new JLabel();
437             jLabels[n].setBounds(250, n*39, 100, 39);
438             jLabels[n].setFont(new Font("宋体", Font.PLAIN, 16));
439             jPaneL.add(jLabels[n]);
440         }
441 
442         for(int n=75;n<150;n++) {
443             jTextFields[n]=new JTextField();
444             jTextFields[n].setBounds(600, (n-75)*39, 50, 39);
445             jTextFields[n].setFont(new Font("宋体", Font.PLAIN, 32));
446             jPaneL.add(jTextFields[n]);
447 
448             jLabels[n]=new JLabel();
449             jLabels[n].setBounds(650, (n-75)*39, 100, 39);
450             jLabels[n].setFont(new Font("宋体", Font.PLAIN, 16));
451             jPaneL.add(jLabels[n]);
452         }
453 
454         for(int n=150;n<225;n++) {
455             jTextFields[n]=new JTextField();
456             jTextFields[n].setBounds(1000, (n-150)*39, 50, 39);
457             jTextFields[n].setFont(new Font("宋体", Font.PLAIN, 32));
458             jPaneL.add(jTextFields[n]);
459 
460             jLabels[n]=new JLabel();
461             jLabels[n].setBounds(1050, (n-150)*39, 100, 39);
462             jLabels[n].setFont(new Font("宋体", Font.PLAIN, 16));
463             jPaneL.add(jLabels[n]);
464         }
465 
466         for(int n=225;n<300;n++) {
467             jTextFields[n]=new JTextField();
468             jTextFields[n].setBounds(1400, (n-225)*39, 50, 39);
469             jTextFields[n].setFont(new Font("宋体", Font.PLAIN, 32));
470             jPaneL.add(jTextFields[n]);
471 
472             jLabels[n]=new JLabel();
473             jLabels[n].setBounds(1450, (n-225)*39, 100, 39);
474             jLabels[n].setFont(new Font("宋体", Font.PLAIN, 16));
475             jPaneL.add(jLabels[n]);
476         }
477 
478         jButton1=new JButton("确定");
479 
480         jButton1.setBounds(1400, 2950, 100, 50);
481         jButton1.setFont(new Font("宋体", Font.PLAIN, 32));
482 
483         jPaneL.add(jButton1);
484 
485         // 创建滚动面板, 指定滚动显示的视图组件(textArea), 垂直滚动条一直显示, 水平滚动条从不显示
486         JScrollPane scrollPane = new JScrollPane(
487                 jPaneL,
488                 ScrollPaneConstants.VERTICAL_SCROLLBAR_ALWAYS,
489                 ScrollPaneConstants.HORIZONTAL_SCROLLBAR_NEVER
490         );
491 
492         jf.setSize(1700,3075);
493         scrollPane.getHorizontalScrollBar().setUnitIncrement(5000);
494         jf.setContentPane(scrollPane);
495         jf.setVisible(true);
496 
497         jPaneL.setPreferredSize(new Dimension(1700,3075));
498     }
499 
500     void setListener(CalculateListener calculateListener) {
501         this.calculateListener=calculateListener;
502         calculateListener.setjTextFields(jTextFields);
503 
504         calculateListener.setjLabels(jLabels);
505         calculateListener.setAnswer1(answer1);
506         calculateListener.setAnswer2(answer2);
507         calculateListener.setAnswer3(answer3);
508         calculateListener.setAnswer4(answer4);
509 
510         for(int i=0;i<300;i++) {
511             jTextFields[i].addActionListener(calculateListener);
512         }
513 
514         jButton1.addActionListener(calculateListener);
515     }
516 }

View Code

CalculateListener.java

  1 import javax.swing.*;
  2 import java.awt.*;
  3 import java.awt.event.ActionEvent;
  4 import java.awt.event.ActionListener;
  5 
  6 public class CalculateListener implements ActionListener {
  7 
  8     JTextField[] jTextFields=new JTextField[300];
  9     JLabel[] jLabels=new  JLabel[300];
 10 
 11     Integer[] answer1;
 12     Integer[] answer2;
 13     Integer[] answer3;
 14     Integer[] answer4;
 15 
 16     public void setjTextFields(JTextField[] jTextFields) {
 17         for(int i=0;i<300;i++)
 18         {
 19             //this.jTextFields[i]=new JTextField();
 20             this.jTextFields[i] = jTextFields[i];
 21         }
 22 
 23     }
 24 
 25     public void setAnswer1(Integer[] answer1) {
 26         this.answer1 = answer1;
 27     }
 28 
 29     public void setAnswer2(Integer[] answer2) {
 30         this.answer2 = answer2;
 31     }
 32 
 33     public void setAnswer3(Integer[] answer3) {
 34         this.answer3 = answer3;
 35     }
 36 
 37     public void setAnswer4(Integer[] answer4) {
 38         this.answer4 = answer4;
 39     }
 40 
 41     public void setjLabels(JLabel[] jLabels) {
 42         for(int i=0;i<300;i++)
 43         {
 44             //this.jLabels[i]=new JLabel();
 45             this.jLabels[i] = jLabels[i];
 46         }
 47     }
 48 
 49     @Override
 50     public void actionPerformed(ActionEvent e) {
 51         for(int i=0;i<75;i++)
 52         {
 53             //jLabels[i]=new JLabel();
 54             if(Integer.toString(answer1[i]).equals(jTextFields[i].getText()))
 55             {
 56                 jLabels[i].setText("正确");
 57                 jLabels[i].setForeground(Color.green);
 58             }
 59             else
 60             {
 61                 jLabels[i].setText("错误"+" "+Integer.toString(answer1[i]));
 62                 jLabels[i].setForeground(Color.red);
 63             }
 64             System.out.println(Integer.toString(answer1[i])+" "+jTextFields[i].getText()+"*");
 65         }
 66         for(int i=75;i<150;i++)
 67         {
 68             //jLabels[i]=new JLabel();
 69             if(Integer.toString(answer2[i-75]).equals(jTextFields[i].getText()))
 70             {
 71                 jLabels[i].setText("正确");
 72                 jLabels[i].setForeground(Color.green);
 73             }
 74             else
 75             {
 76                 jLabels[i].setText("错误"+" "+Integer.toString(answer2[i-75]));
 77                 jLabels[i].setForeground(Color.red);
 78             }
 79         }
 80         for(int i=150;i<225;i++)
 81         {
 82             //jLabels[i]=new JLabel();
 83             if(Integer.toString(answer3[i-150]).equals(jTextFields[i].getText()))
 84             {
 85                 jLabels[i].setText("正确");
 86                 jLabels[i].setForeground(Color.green);
 87             }
 88             else
 89             {
 90                 jLabels[i].setText("错误"+" "+Integer.toString(answer3[i-150]));
 91                 jLabels[i].setForeground(Color.red);
 92             }
 93         }
 94         for(int i=225;i<300;i++)
 95         {
 96             //jLabels[i]=new JLabel();
 97             if(Integer.toString(answer4[i-225]).equals(jTextFields[i].getText()))
 98             {
 99                 jLabels[i].setText("正确");
100                 jLabels[i].setForeground(Color.green);
101             }
102             else
103             {
104                 jLabels[i].setText("错误"+" "+Integer.toString(answer4[i-225]));
105                 jLabels[i].setForeground(Color.red);
106             }
107         }
108     }
109 }

View Code

MenuWindow.java

  1 import javax.swing.*;
  2 import java.awt.*;
  3 import java.util.Random;
  4 
  5 public class CalculateWindow extends JFrame{
  6     JPanel jPaneL;
  7 
  8     JList <Integer> jList1;
  9     JList <String> jList2;
 10     JList <Integer> jList3;
 11     JList <String> jList4;
 12 
 13     JList <Integer> jList5;
 14     JList <String> jList6;
 15     JList <Integer> jList7;
 16     JList <String> jList8;
 17 
 18     JList <Integer> jList9;
 19     JList <String> jList10;
 20     JList <Integer> jList11;
 21     JList <String> jList12;
 22 
 23     JList <Integer> jList13;
 24     JList <String> jList14;
 25     JList <Integer> jList15;
 26     JList <String> jList16;
 27 
 28     JTextField[] jTextFields=new JTextField[300];
 29     JLabel[] jLabels=new JLabel[300];
 30 
 31     JButton jButton1;
 32     CalculateListener calculateListener=new CalculateListener();
 33 
 34     private Integer[] a = new Integer[75];
 35     private Integer[] b = new Integer[75];
 36     private Integer[] c = new Integer[75];
 37     private Integer[] d = new Integer[75];
 38     private Integer[] e = new Integer[75];
 39     private Integer[] f = new Integer[75];
 40     private Integer[] g = new Integer[75];
 41     private Integer[] h = new Integer[75];
 42 
 43     private Integer[] answer1 = new Integer[75];
 44     private Integer[] answer2 = new Integer[75];
 45     private Integer[] answer3 = new Integer[75];
 46     private Integer[] answer4 = new Integer[75];
 47 
 48     private String[] sign=new String[75];
 49     private String[] equal=new String[75];
 50 
 51     void create() {
 52         JFrame jf = new JFrame("四则运算练习器");
 53         jf.setLayout(null);
 54         jf.setSize(1700, 1025);
 55         jf.setLocationRelativeTo(null);
 56         jf.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
 57 
 58         jPaneL=new JPanel();
 59         jPaneL.setLayout(null);
 60 
 61         Random random1 = new Random();
 62         int count1 = 0;
 63         while (count1 < a.length) {
 64             Boolean flag1 = true;
 65             Integer r1 = random1.nextInt(100);     //生成100以内的随机数
 66             for (int i = 0; i < a.length; i++) {
 67                 if (r1 == a[i]) {
 68                     flag1 = false;
 69                     break;
 70                 }
 71             }
 72             if (flag1) {
 73                 a[count1] = r1;
 74                 System.out.println(a[count1]);
 75                 count1++;
 76             }
 77         }
 78 
 79         Random random2 = new Random();
 80         int count2 = 0;
 81         while (count2 < b.length) {
 82             Boolean flag2 = true;
 83             Integer r2 = random2.nextInt(100);     //生成100以内的随机数
 84             for (int i = 0; i < b.length; i++) {
 85                 if (r2 == b[i]||(Listener.flag4 && r2==0)) {
 86                     flag2 = false;
 87                     break;
 88                 }
 89             }
 90             if (flag2) {
 91                 b[count2] = r2;
 92                 System.out.println(r2);
 93                 count2++;
 94             }
 95         }
 96 
 97         Random random3 = new Random();
 98         int count3 = 0;
 99         while (count3 < c.length) {
100             Boolean flag3 = true;
101             Integer r3 = random3.nextInt(100);     //生成100以内的随机数
102             for (int i = 0; i < c.length; i++) {
103                 if (r3 == c[i]) {
104                     flag3 = false;
105                     break;
106                 }
107             }
108             if (flag3) {
109                 c[count3] = r3;
110                 System.out.println(r3);
111                 count3++;
112             }
113         }
114 
115         Random random4 = new Random();
116         int count4 = 0;
117         while (count4 < d.length) {
118             Boolean flag4 = true;
119             Integer r4 = random4.nextInt(100);     //生成100以内的随机数
120             for (int i = 0; i < d.length; i++) {
121                 if (r4 == d[i]||(Listener.flag4 && r4==0)) {
122                     flag4 = false;
123                     break;
124                 }
125             }
126             if (flag4) {
127                 d[count4] = r4;
128                 System.out.println(r4);
129                 count4++;
130             }
131         }
132 
133         Random random5 = new Random();
134         int count5 = 0;
135         while (count5 < e.length) {
136             Boolean flag5 = true;
137             Integer r5 = random5.nextInt(100);     //生成100以内的随机数
138             for (int i = 0; i < e.length; i++) {
139                 if (r5 == e[i]) {
140                     flag5 = false;
141                     break;
142                 }
143             }
144             if (flag5) {
145                 e[count5] = r5;
146                 System.out.println(r5);
147                 count5++;
148             }
149         }
150 
151         Random random6 = new Random();
152         int count6 = 0;
153         while (count6 < f.length) {
154             Boolean flag6 = true;
155             Integer r6 = random6.nextInt(100);     //生成100以内的随机数
156             for (int i = 0; i < f.length; i++) {
157                 if (r6 == f[i]||(Listener.flag4 && r6==0)) {
158                     flag6 = false;
159                     break;
160                 }
161             }
162             if (flag6) {
163                 f[count6] = r6;
164                 System.out.println(r6);
165                 count6++;
166             }
167         }
168 
169         Random random7 = new Random();
170         int count7 = 0;
171         while (count7 < g.length) {
172             Boolean flag7 = true;
173             Integer r7 = random7.nextInt(100);     //生成100以内的随机数
174             for (int i = 0; i < g.length; i++) {
175                 if (r7 == g[i]) {
176                     flag7 = false;
177                     break;
178                 }
179             }
180             if (flag7) {
181                 g[count7] = r7;
182                 System.out.println(r7);
183                 count7++;
184             }
185         }
186 
187         Random random8 = new Random();
188         int count8 = 0;
189         while (count8 < h.length) {
190             Boolean flag8 = true;
191             Integer r8 = random8.nextInt(100);     //生成100以内的随机数
192             for (int i = 0; i < h.length; i++) {
193                 if (r8 == h[i]||(Listener.flag4 && r8==0)) {
194                     flag8 = false;
195                     break;
196                 }
197             }
198             if (flag8) {
199                 h[count8] = r8;
200                 System.out.println(r8);
201                 count8++;
202             }
203         }
204 
205         if(Listener.flag1&&!Listener.flag2&&!Listener.flag3&&!Listener.flag4) {
206             for(int i=0;i<75;i++)
207                 sign[i]="+";
208         } else if(Listener.flag2&&!Listener.flag1&&!Listener.flag3&&!Listener.flag4) {
209             for(int i=0;i<75;i++)
210                 sign[i]="-";
211         } else if(Listener.flag3&&!Listener.flag1&&!Listener.flag2&&!Listener.flag4) {
212             for(int i=0;i<75;i++)
213                 sign[i]="*";
214         } else if(Listener.flag4&&!Listener.flag1&&!Listener.flag2&&!Listener.flag3) {
215             for(int i=0;i<75;i++)
216                 sign[i]="/";
217         } else if(Listener.flag1&&Listener.flag2&&!Listener.flag3&&!Listener.flag4) {
218             for(int i=0;i<75;i++) {
219                 Integer s = random1.nextInt(2);
220                 if(s==0) {
221                     sign[i] = "+";
222                 } else if(s==1) {
223                     sign[i] = "-";
224                 }
225             }
226         } else if(Listener.flag1&&Listener.flag3&&!Listener.flag2&&!Listener.flag4) {
227             for(int i=0;i<75;i++) {
228                 Random random = new Random();
229                 Integer s = random.nextInt(2);
230                 if(s==0) {
231                     sign[i] = "+";
232                 } else if(s==1) {
233                     sign[i] = "*";
234                 }
235             }
236         } else if(Listener.flag1&&Listener.flag4&&!Listener.flag2&&!Listener.flag3) {
237             for(int i=0;i<75;i++) {
238                 Random random = new Random();
239                 Integer s = random.nextInt(2);
240                 if(s==0) {
241                     sign[i] = "+";
242                 } else if(s==1) {
243                     sign[i] = "/";
244                 }
245             }
246         } else if(Listener.flag2&&Listener.flag3&&!Listener.flag1&&!Listener.flag4) {
247             for(int i=0;i<75;i++) {
248                 Random random = new Random();
249                 Integer s = random.nextInt(2);
250                 if(s==0) {
251                     sign[i] = "-";
252                 } else if(s==1) {
253                     sign[i] = "*";
254                 }
255             }
256         } else if(Listener.flag2&&Listener.flag4&&!Listener.flag3&&!Listener.flag1) {
257             for(int i=0;i<75;i++) {
258                 Random random = new Random();
259                 Integer s = random.nextInt(2);
260                 if(s==0) {
261                     sign[i] = "-";
262                 } else if(s==1) {
263                     sign[i] = "/";
264                 }
265             }
266         } else if(Listener.flag3&&Listener.flag4&&!Listener.flag1&&!Listener.flag2) {
267             for(int i=0;i<75;i++) {
268                 Random random = new Random();
269                 Integer s = random.nextInt(2);
270                 if(s==0) {
271                     sign[i] = "*";
272                 } else if(s==1) {
273                     sign[i] = "/";
274                 }
275             }
276         } else if(Listener.flag1&&Listener.flag2&&Listener.flag3&&!Listener.flag4) {
277             for(int i=0;i<75;i++) {
278                 Random random = new Random();
279                 Integer s = random.nextInt(3);
280                 if(s==0) {
281                     sign[i] = "+";
282                 } else if(s==1) {
283                     sign[i] = "-";
284                 } else if(s==2) {
285                     sign[i] = "*";
286                 }
287             }
288         } else if(Listener.flag1&&Listener.flag3&&Listener.flag4&&!Listener.flag2) {
289             for(int i=0;i<75;i++) {
290                 Random random = new Random();
291                 Integer s = random.nextInt(3);
292                 if(s==0) {
293                     sign[i] = "+";
294                 } else if(s==1) {
295                     sign[i] = "*";
296                 } else if(s==2) {
297                     sign[i] = "/";
298                 }
299             }
300         } else if(Listener.flag2&&Listener.flag3&&Listener.flag4&&!Listener.flag1) {
301             for(int i=0;i<75;i++) {
302                 Random random = new Random();
303                 Integer s = random.nextInt(3);
304                 if(s==0) {
305                     sign[i] = "-";
306                 } else if(s==1) {
307                     sign[i] = "*";
308                 } else if(s==2) {
309                     sign[i] = "/";
310                 }
311             }
312         } else if(Listener.flag1&&Listener.flag2&&Listener.flag3&&Listener.flag4) {
313                     for(int i=0;i<75;i++) {
314                         Random random = new Random();
315                         Integer s = random.nextInt(4);
316                         if(s==0) {
317                             sign[i] = "+";
318                         } else if(s==1) {
319                             sign[i] = "-";
320                         } else if(s==2) {
321                             sign[i] = "*";
322                         } else if(s==3) {
323                             sign[i] = "/";
324                         }
325             }
326         }
327 
328         for(int i=0;i<75;i++) {
329             equal[i] = "=";
330         }
331 
332         for(int k=0;k<75;k++) {
333             if(sign[k].equals("+")) {
334                 answer1[k]=a[k]+b[k];
335                 answer2[k]=c[k]+d[k];
336                 answer3[k]=e[k]+f[k];
337                 answer4[k]=g[k]+h[k];
338             } else if(sign[k].equals("-")) {
339                 answer1[k]=a[k]-b[k];
340                 answer2[k]=c[k]-d[k];
341                 answer3[k]=e[k]-f[k];
342                 answer4[k]=g[k]-h[k];
343             } else if(sign[k].equals("*")) {
344                 answer1[k]=a[k]*b[k];
345                 answer2[k]=c[k]*d[k];
346                 answer3[k]=e[k]*f[k];
347                 answer4[k]=g[k]*h[k];
348             } else if(sign[k].equals("/")) {
349                 answer1[k]=a[k]/b[k];
350                 answer2[k]=c[k]/d[k];
351                 answer3[k]=e[k]/f[k];
352                 answer4[k]=g[k]/h[k];
353             }
354         }
355 
356         jList1=new JList<Integer>(a);
357         jList2=new JList<String>(sign);
358         jList3=new JList<Integer>(b);
359         jList4=new JList<String>(equal);
360 
361         jList5=new JList<Integer>(c);
362         jList6=new JList<String>(sign);
363         jList7=new JList<Integer>(d);
364         jList8=new JList<String>(equal);
365 
366         jList9=new JList<Integer>(e);
367         jList10=new JList<String>(sign);
368         jList11=new JList<Integer>(f);
369         jList12=new JList<String>(equal);
370 
371         jList13=new JList<Integer>(g);
372         jList14=new JList<String>(sign);
373         jList15=new JList<Integer>(h);
374         jList16=new JList<String>(equal);
375 
376         jList1.setBounds(0, 0, 50, 2925);
377         jList1.setFont(new Font("宋体", Font.PLAIN, 32));
378         jList2.setBounds(50, 0, 50, 2925);
379         jList2.setFont(new Font("宋体", Font.PLAIN, 32));
380         jList3.setBounds(100, 0, 50, 2925);
381         jList3.setFont(new Font("宋体", Font.PLAIN, 32));
382         jList4.setBounds(150, 0, 50, 2925);
383         jList4.setFont(new Font("宋体", Font.PLAIN, 32));
384 
385         jList5.setBounds(400, 0, 50, 2925);
386         jList5.setFont(new Font("宋体", Font.PLAIN, 32));
387         jList6.setBounds(450, 0, 50, 2925);
388         jList6.setFont(new Font("宋体", Font.PLAIN, 32));
389         jList7.setBounds(500, 0, 50, 2925);
390         jList7.setFont(new Font("宋体", Font.PLAIN, 32));
391         jList8.setBounds(550, 0, 50, 2925);
392         jList8.setFont(new Font("宋体", Font.PLAIN, 32));
393 
394         jList9.setBounds(800, 0, 50, 2925);
395         jList9.setFont(new Font("宋体", Font.PLAIN, 32));
396         jList10.setBounds(850, 0, 50, 2925);
397         jList10.setFont(new Font("宋体", Font.PLAIN, 32));
398         jList11.setBounds(900, 0, 50, 2925);
399         jList11.setFont(new Font("宋体", Font.PLAIN, 32));
400         jList12.setBounds(950, 0, 50, 2925);
401         jList12.setFont(new Font("宋体", Font.PLAIN, 32));
402 
403         jList13.setBounds(1200, 0, 50, 2925);
404         jList13.setFont(new Font("宋体", Font.PLAIN, 32));
405         jList14.setBounds(1250, 0, 50, 2925);
406         jList14.setFont(new Font("宋体", Font.PLAIN, 32));
407         jList15.setBounds(1300, 0, 50, 2925);
408         jList15.setFont(new Font("宋体", Font.PLAIN, 32));
409         jList16.setBounds(1350, 0, 50, 2925);
410         jList16.setFont(new Font("宋体", Font.PLAIN, 32));
411 
412         jPaneL.add(jList1);
413         jPaneL.add(jList2);
414         jPaneL.add(jList3);
415         jPaneL.add(jList4);
416         jPaneL.add(jList5);
417         jPaneL.add(jList6);
418         jPaneL.add(jList7);
419         jPaneL.add(jList8);
420         jPaneL.add(jList9);
421         jPaneL.add(jList10);
422         jPaneL.add(jList11);
423         jPaneL.add(jList12);
424         jPaneL.add(jList13);
425         jPaneL.add(jList14);
426         jPaneL.add(jList15);
427         jPaneL.add(jList16);
428 
429         for(int n=0;n<75;n++) {
430             jTextFields[n]=new JTextField();
431             jTextFields[n].setBounds(200, n*39, 50, 39);
432             jTextFields[n].setFont(new Font("宋体", Font.PLAIN, 32));
433             jPaneL.add(jTextFields[n]);
434 
435             jLabels[n]=new JLabel();
436             jLabels[n].setBounds(250, n*39, 100, 39);
437             jLabels[n].setFont(new Font("宋体", Font.PLAIN, 16));
438             jPaneL.add(jLabels[n]);
439         }
440 
441         for(int n=75;n<150;n++) {
442             jTextFields[n]=new JTextField();
443             jTextFields[n].setBounds(600, (n-75)*39, 50, 39);
444             jTextFields[n].setFont(new Font("宋体", Font.PLAIN, 32));
445             jPaneL.add(jTextFields[n]);
446 
447             jLabels[n]=new JLabel();
448             jLabels[n].setBounds(650, (n-75)*39, 100, 39);
449             jLabels[n].setFont(new Font("宋体", Font.PLAIN, 16));
450             jPaneL.add(jLabels[n]);
451         }
452 
453         for(int n=150;n<225;n++) {
454             jTextFields[n]=new JTextField();
455             jTextFields[n].setBounds(1000, (n-150)*39, 50, 39);
456             jTextFields[n].setFont(new Font("宋体", Font.PLAIN, 32));
457             jPaneL.add(jTextFields[n]);
458 
459             jLabels[n]=new JLabel();
460             jLabels[n].setBounds(1050, (n-150)*39, 100, 39);
461             jLabels[n].setFont(new Font("宋体", Font.PLAIN, 16));
462             jPaneL.add(jLabels[n]);
463         }
464 
465         for(int n=225;n<300;n++) {
466             jTextFields[n]=new JTextField();
467             jTextFields[n].setBounds(1400, (n-225)*39, 50, 39);
468             jTextFields[n].setFont(new Font("宋体", Font.PLAIN, 32));
469             jPaneL.add(jTextFields[n]);
470 
471             jLabels[n]=new JLabel();
472             jLabels[n].setBounds(1450, (n-225)*39, 100, 39);
473             jLabels[n].setFont(new Font("宋体", Font.PLAIN, 16));
474             jPaneL.add(jLabels[n]);
475         }
476 
477         jButton1=new JButton("确定");
478 
479         jButton1.setBounds(1400, 2950, 100, 50);
480         jButton1.setFont(new Font("宋体", Font.PLAIN, 32));
481 
482         jPaneL.add(jButton1);
483 
484         // 创建滚动面板, 指定滚动显示的视图组件(textArea), 垂直滚动条一直显示, 水平滚动条从不显示
485         JScrollPane scrollPane = new JScrollPane(
486                 jPaneL,
487                 ScrollPaneConstants.VERTICAL_SCROLLBAR_ALWAYS,
488                 ScrollPaneConstants.HORIZONTAL_SCROLLBAR_NEVER
489         );
490 
491         jf.setSize(1700,3075);
492         scrollPane.getHorizontalScrollBar().setUnitIncrement(5000);
493         jf.setContentPane(scrollPane);
494         jf.setVisible(true);
495 
496         jPaneL.setPreferredSize(new Dimension(1700,3075));
497     }
498 
499     void setListener(CalculateListener calculateListener) {
500         this.calculateListener=calculateListener;
501         calculateListener.setjTextFields(jTextFields);
502 
503         calculateListener.setjLabels(jLabels);
504         calculateListener.setAnswer1(answer1);
505         calculateListener.setAnswer2(answer2);
506         calculateListener.setAnswer3(answer3);
507         calculateListener.setAnswer4(answer4);
508 
509         for(int i=0;i<300;i++) {
510             jTextFields[i].addActionListener(calculateListener);
511         }
512 
513         jButton1.addActionListener(calculateListener);
514     }
515 }

View Code

Listener.java

 1 import javax.swing.*;
 2 import java.awt.event.ActionEvent;
 3 import java.awt.event.ActionListener;
 4 
 5 public class Listener implements ActionListener {
 6 
 7     static Boolean flag1=false;
 8     static Boolean flag2=false;
 9     static Boolean flag3=false;
10     static Boolean flag4=false;
11 
12     JCheckBox jCheckBox1;
13     JCheckBox jCheckBox2;
14     JCheckBox jCheckBox3;
15     JCheckBox jCheckBox4;
16 
17     CalculateWindow calculateWindow=new CalculateWindow();
18 
19     public void setJCeckBox1(JCheckBox jCeckBox) {
20         this.jCheckBox1=jCeckBox;
21     }
22 
23     public void setJCeckBox2(JCheckBox jCeckBox) {
24         this.jCheckBox2=jCeckBox;
25     }
26 
27     public void setJCeckBox3(JCheckBox jCeckBox) {
28         this.jCheckBox3=jCeckBox;
29     }
30 
31     public void setJCeckBox4(JCheckBox jCeckBox) {
32         this.jCheckBox4=jCeckBox;
33     }
34 
35     @Override
36     public void actionPerformed(ActionEvent e) {
37         if(jCheckBox1.isSelected()) {
38             flag1 = true;
39         }
40         if(jCheckBox2.isSelected()) {
41             flag2 = true;
42         }
43         if(jCheckBox3.isSelected()) {
44             flag3 = true;
45         }
46         if(jCheckBox4.isSelected()) {
47             flag4 = true;
48         }
49 
50         calculateWindow.create();
51         calculateWindow.setLayout(null);
52         CalculateListener calculateListener=new CalculateListener();
53         calculateWindow.setListener(calculateListener);
54 
55         flag1=false;
56         flag2=false;
57         flag3=false;
58         flag4=false;
59     }
60 }

View Code

Main.java

 1 import java.awt.*;
 2 
 3 public class Main {
 4         public static void main(String args[])
 5         {
 6             MenuWindow win=new MenuWindow();
 7             Listener listener=new Listener();
 8 
 9             win.create();
10             win.setListener(listener);
11             win.setBounds(0,0,2000,1025);
12             win.setLayout(new BorderLayout());
13             win.setTitle("四则运算练习器");
14         }
15 }

View Code

五、代码复查

复查前：

存在11个文件，逻辑结构不够清晰，编码格式较乱，代码重复率过高且功能呢个不够完善。

复查后：

精简为5个文件，有较为清晰的逻辑结构，对编码格式进行了订正，且以较之前更为简化的代码实现了更多的功能。

六、心得体会

在编程的过程中，当遇到瓶颈沮丧的时候，我们相互鼓励；当遇到困难畏惧的时候，我们相互监督；我们互相学习，共同进步，这就是结对编程的魅力。通过结对编程，我们不断地学习如何与他人沟通以解决困难，如何与他人协作来完成项目。

除此之外，代码复查不仅让我们提高了自己的代码质量，使代码的逻辑结构更加清晰，编码风格更加规范。在代码复查的过程中，我们还互相交流想法与经验，锻炼与提高自己的能力，在失败中不断吸取教训。

通过这次作业，我们深刻感受到了结对编程的优点，以及代码复查的重要性。

在今后的编程中，我们一定会把这次作业总结下来的经验教训应用到工作中去。

查看全文

相关阅读:
go-pg库操作PostgreSQL小结
 Python与Golang中实现单例模式
 MySQL与PostgreSQL中解决插入主键冲突的方法
 jemeter
Java后端面试题集
 java 多线程
 Git入门级必知操作，从拉取到冲突、合并、推送真实流程演示
 一小时,从零实现Java人脸识别功能,opencv
新入手服务器不会玩？抢占式实例服务器教程，从零搭建tomcat超简流程
 sharding+mybatisplus单库分表部署

原文地址：https://www.cnblogs.com/cwqbs/p/10556239.html