目    录

1 选题

2 系统需求分析

3.1 系统可行性分析 

3.2 系统需求分析 

3.3 项目进度安排

3 系统设计

4.1 系统设计

4.2 文件设计（有则写-无则删除，如果是文件直接写文件）

4 系统实现

5.1 猜数游戏界面实现

5.2 简易计算器界面实现

5 系统测试

6 结论和心得

1 选题
选题一

猜数游戏

题目要求

计算机产生随机数，猜中即胜，猜不中，提示是大了还是小了，

继续猜，直至猜到，给出所用时间和评语。

保留用户测试成绩，做出成绩排行榜。

排行榜存放到文件或数据库中。

使用Java知识

（1）Scanner用户键盘录入

（2）switch-case语句

（3）io流

（4）数组（排序）

（5）Random生成随机数

（6）long startTime = System.currentTimeMillis();计时器

（7）try-catch捕获异常

选题二

简易计算器模拟程序

题目要求

仿照Windows计算器,编写一具有GUI的计算器，

能实现整数的加、减、乘、除四则运算。

历次计算需存放在文件或数据库中，下回启动可重复使用。

使用Java知识

（1）图形界面

（2）JPanel：面板  JTextField：文本编辑框  JLable：标签  JButton：按钮

（3）设计监听事件及监听事件的处理

（4）try-catch捕获异常

2 系统需求分析
2.1 系统可行性分析
猜数游戏：程序能够成功运行，控制台能够正常显示猜数游戏过程。

简易计算器模拟程序：程序能够成功运行，能够正常显示计算器界面且可实现其功能。

2.2 系统需求分析
调研对象：老师、同组同学、三组组长、十组成员

猜数游戏：Random生成随机数作为用户要猜的数，for循环控制参加游戏的用户人数，Scanner用户键盘录入所猜的数，统计猜测次数与所用时间 ，得出分数，给出评语，将数据存入文件，最后根据分数排序作出排行榜。

简易计算器模拟程序：利用GUI图形界面，设计面板、标签、文本编辑框、按钮等，实现简单的四则运算。

图3-1 猜数游戏流程图

图3-2 简易计算器流程图

2.3 进度安排
阶段一进度安排如表3-1所示。

表3-1 进度安排表

阶段

持续时间

阶段描述

输出

构思阶段

一小时

需求分析

需求说明，功能模块图

设计阶段

一个半小时

系统设计

设计说明-可以画流程图；文件设计

实现阶段

一天半

编写代码

项目工程源代码

五小时

系统测试

进行黑盒测试（功能测试）-测试说明

运行阶段

三小时

部署、运行

系统使用说明、运维报告、录制视频

3 系统设计
3.1 系统设计
根据系统的实际功能需求分析，对系统功能部分进行了设计。

猜数游戏：

（1）用户键盘录入

Scanner input = new Scanner(System.in);
1.
（2）输入用户姓名以及参与游戏的人数

String name = input.next();
int user = input.nextInt();
1.
2.
（3）产生随机数，作为要猜的数

int number = (int) (Math.random() * 100 + 1);
1.
（4）猜数过程

while(guessnum != number) {
猜错了，根据结果，给出提示，接着猜数，游戏继续
if(guessnum>100 || guessnum<0) {
System.out.println("输入有误，请重新输入！");
return;
}else if(guessnum > number) {
System.out.print("猜大了，请重新猜测：");
guessnum = input.nextInt();
count++;counts[i] += 1;
}else {
System.out.print("猜小了，请重新猜测：");
guessnum = input.nextInt();
count++;counts[i] += 1;
}
}
（5）统计次数
int count;
count++;
（6）记录时间
long startTime = System.currentTimeMillis();
long endTime = System.currentTimeMillis();
（7）存入文件
fw = new FileWriter("D:\\GuessNumberGame\\read.txt",true);
用户成绩：");
String score1 = Integer.toString(score);
fw.write(score1);
分\t");
System.out.println("保存成功！\n");
fw.close();
}
}catch(Exception e) {
e.printStackTrace();
}
（8）排行榜
Arrays.sort(counts);
for(int scores:counts) {
System.out.println(scores+"\t");
System.out.println("****************************\n");
}
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.
20.
21.
22.
23.
24.
25.
26.
27.
28.
29.
30.
31.
32.
33.
34.
35.
36.
37.
38.
39.
 

源码：

1 package com.GuessNumeberGame;
2
3 import java.io.*;
4
5 import java.util.*;
6
7 public class GuessNumber {
8
9 public static void main(String[] args) throws IOException {
10
11 //创建键盘录入对象
12
13 Scanner input = new Scanner(System.in);
14
15 //创建字符流对象
16
17 Writer fw = null;
18
19 //定义参加游戏的用户人数
20
21 System.out.print("请输入参与游戏的用户人数：");
22
23 int user = input.nextInt();
24
25 //定义猜测的次数
26
27 int count;
28
29 //用数组来存放猜测次数
30
31 int[] counts = new int[user];
32
33 //定义成绩
34
35 int score = 0;
36
37 //捕获可能出现的异常，例如：输入所猜数不是数字，是A
38
39 try {
40
41 //循环控制人数
42
43 for(int i = 0;i < user;i++) {
44
45 //初始化
46
47 count = 0;
48
49 System.out.println("***** 您是第"+(i+1)+"位用户 ***** ");
50
51 System.out.print("请输入您的姓名：");
52
53 String name = input.next();
54
55 //生成随机数作为要猜的数
56
57 int number = (int) (Math.random() * 100 + 1);
58
59 long startTime = System.currentTimeMillis();//获取程序开始时间
60
61 System.out.print("请输入您猜的数：");
62
63 int guessnum = input.nextInt();
64
65 count++;//次数加1
66
67 counts[i] += 1;
68
69
70
71 //通过while循环，进行猜数字对错判断
72
73 //猜错，继续游戏；猜对，跳出循环，游戏结束
74
75 while(guessnum != number) {
76
77 //猜错了，根据结果，给出提示，接着猜数，游戏继续
78
79 if(guessnum>100 || guessnum<0) {
80
81 System.out.println("输入有误，请重新输入！");
82
83 return;
84
85 }else if(guessnum > number) {
86
87 System.out.print("猜大了，请重新猜测：");
88
89 guessnum = input.nextInt();
90
91 count++;counts[i] += 1;
92
93 }else {
94
95 System.out.print("猜小了，请重新猜测：");
96
97 guessnum = input.nextInt();
98
99 count++;counts[i] += 1;
100
101 }
102
103 }
104
105 long endTime = System.currentTimeMillis();//获取结束时间
106
107 //由于猜测次数可能相同，所以把猜测次数与时间相加作为分数
108
109 score = (int)((endTime-startTime)/1000) + count;
110
111 counts[i] = score;
112
113 System.out.println("恭喜您，猜对了！此次游戏的正确答案是："+number);
114
115 System.out.println("您一共猜测了"+count+"次猜数时长为："+(endTime-startTime)/1000+"s");
116
117 //输出给该用户的评语
118
119 System.out.print("评语：");
120
121 switch(count) {
122
123 case 1:
124
125 System.out.println("您太棒了，一次就猜对了！");
126
127 break;
128
129 case 2:
130
131 case 3:
132
133 case 4:
134
135 case 5:
136
137 System.out.println("还不错嘛！这么快就猜对了！");
138
139 break;
140
141 case 6:
142
143 case 7:
144
145 System.out.println("有点遗憾，再接再厉哦！");
146
147 break;
148
149 default:
150
151 System.out.println("猜了这么久才猜对，还要多多练习哦！");
152
153 break;
154
155 }
156
157 System.out.println("您的成绩是："+score+"分");
158
159 //写入文件
160
161 fw = new FileWriter("D:\\GuessNumberGame\\read.txt",true);
162
163 fw.write("用户姓名：");
164
165 fw.write(name);
166
167 fw.write("\t");
168
169 fw.write("所用时间：");
170
171 long time = ((endTime-startTime)/1000);
172
173 String time1 = Long.toString(time);
174
175 fw.write(time1);
176
177 fw.write("s\t");
178
179 fw.write("用户成绩：");
180
181 String score1 = Integer.toString(score);
182
183 fw.write(score1);
184
185 fw.write("分\t");
186
187 System.out.println("保存成功！\n");
188
189 fw.close();
190
191 }
192
193 }catch(Exception e) {
194
195 e.printStackTrace();
196
197 }
198
199 //排行榜
200
201 System.out.println("***********排行榜**********");
202
203 //根据用户所得分数来进行排序，分数较少位于排行榜前方
204
205 Arrays.sort(counts);
206
207 for(int scores:counts) {
208
209 System.out.println(scores+"\t");
210
211 System.out.println("****************************\n");
212
213 }
214
215 System.out.println("本轮游戏结束，大家可以退出游戏了！\n");
216
217 }
218
219 }
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.
20.
21.
22.
23.
24.
25.
26.
27.
28.
29.
30.
31.
32.
33.
34.
35.
36.
37.
38.
39.
40.
41.
42.
43.
44.
45.
46.
47.
48.
49.
50.
51.
52.
53.
54.
55.
56.
57.
58.
59.
60.
61.
62.
63.
64.
65.
66.
67.
68.
69.
70.
71.
72.
73.
74.
75.
76.
77.
78.
79.
80.
81.
82.
83.
84.
85.
86.
87.
88.
89.
90.
91.
92.
93.
94.
95.
96.
97.
98.
99.
100.
101.
102.
103.
104.
105.
106.
107.
108.
109.
110.
111.
112.
113.
114.
115.
116.
117.
118.
119.
120.
121.
122.
123.
124.
125.
126.
127.
128.
129.
130.
131.
132.
133.
134.
135.
136.
137.
138.
139.
140.
141.
142.
143.
144.
145.
146.
147.
148.
149.
150.
151.
152.
153.
154.
155.
156.
157.
158.
159.
160.
161.
162.
163.
164.
165.
166.
167.
168.
169.
170.
171.
172.
173.
174.
175.
176.
177.
178.
179.
180.
181.
182.
183.
184.
185.
186.
187.
188.
189.
190.
191.
192.
193.
194.
195.
196.
197.
198.
199.
200.
201.
202.
203.
204.
205.
206.
207.
208.
209.
210.
211.
212.
213.
214.
215.
216.
217.
218.
219.
 

简易计算器：

源码：

1 package com.SimpleCalculator;
2
3
4
5 import java.awt.*;
6
7 import java.awt.event.*;
8
9 import java.io.BufferedReader;
10
11 import java.io.FileNotFoundException;
12
13 import java.io.FileOutputStream;
14
15 import java.io.FileReader;
16
17 import java.io.FileWriter;
18
19 import java.io.IOException;
20
21 import java.io.Writer;
22
23 import javax.swing.*;
24
25 import javax.swing.border.EmptyBorder;
26
27 public class counter extends JFrame implements ActionListener {
28
29 //创建面板对象分别放置编辑框及标签
30
31 private JPanel jp1 = new JPanel();
32
33 private JPanel jp2 = new JPanel();
34
35 private JPanel jp3 = new JPanel();
36
37 //定义文本编辑框
38
39 private JTextField jt1;
40
41 //定义标签
42
43 private JLabel label;
44
45 //可变字符串，显示屏所显示的字符串
46
47 StringBuffer str;
48
49 //定义两个操作数
50
51 double x,y;
52
53 //z表示单击了哪一个运算符。0表示"+",1表示"-",2表示"*",3表示"/"
54
55 int z;
56
57 //创建一个有12个按钮的数组
58
59 private JButton jb[] = new JButton[12];
60
61 private JButton jb1,jb2,jb3,jb4,jb5,jb6,jb7,jb8;//算术功能按钮
62
63 public counter() {
64
65 //对计算器整体框架的建立
66
67 super("简易计算器");//窗口名称
68
69 //初始化一个容器
70
71 Container c = getContentPane();//创建内容面板对象
72
73 jt1 = new JTextField(30);
74
75 jt1.setEditable(false);//文本框只能显示，不可编辑
76
77 //给文本编辑框设置颜色
78
79 jt1.setBackground(Color.green);
80
81 label = new JLabel("欢迎使用简易计算器!");
82
83 //设置标签字体样式、颜色
84
85 label.setFont(new Font("楷体",Font.BOLD,20));
86
87 label.setForeground(Color.pink);
88
89 //设置标签居中
90
91 label.setHorizontalAlignment(JLabel.CENTER);
92
93 /*-JLabel background = new JLabel(new ImageIcon("D:back.jpg"));
94
95 c.add(background);
96
97 ((JPanel)c).setOpaque(false);*/
98
99 //创建一个空字符串缓冲区
100
101 str = new StringBuffer();
102
103 //添加标签到面板
104
105 jp2.add(label);
106
107 //添加文本框到面板
108
109 jp2.add(jt1);
110
111 //设置布局样式
112
113 jp2.setLayout(new GridLayout(4,1));
114
115 //分别为数组中0~9号的按钮设置标签，并注册监听器
116
117 for(int i = 0;i < 10;i++) {
118
119 String s = "" + i;
120
121 jb[i] = new JButton(s);
122
123 //设置按钮中字体样式
124
125 jb[i].setFont(new Font("楷体",Font.BOLD,15));
126
127 //给按钮注册监听器
128
129 jb[i].addActionListener(this);
130
131 }
132
133 //实例化各个按钮
134
135 jb[10]= new JButton("-/+"); jb[11]= new JButton(".");
136
137 jb1= new JButton("+"); jb2= new JButton("←");
138
139 jb3= new JButton("-"); jb4= new JButton("AC");
140
141 jb5= new JButton("*"); jb6= new JButton("√");
142
143 jb7= new JButton("/"); jb8= new JButton("=");
144
145 //设置按钮前景色
146
147 for(int i=0;i<12;i++)
148
149 {
150
151 jb[i].setForeground(Color.blue);
152
153 }
154
155 jb1.setForeground(Color.red); jb3.setForeground(Color.red);
156
157 jb5.setForeground(Color.red); jb7.setForeground(Color.red);
158
159 jb2.setForeground(Color.blue); jb4.setForeground(Color.blue);
160
161 jb6.setForeground(Color.red); jb8.setForeground(Color.blue);
162
163 //把每个按钮添加到面板上
164
165 jp1.add(jb[1]); jp1.add(jb[2]); jp1.add(jb[3]); jp1.add(jb1); jp1.add(jb2);
166
167 jp1.add(jb[4]); jp1.add(jb[5]); jp1.add(jb[6]); jp1.add(jb3); jp1.add(jb4);
168
169 jp1.add(jb[7]); jp1.add(jb[8]); jp1.add(jb[9]); jp1.add(jb5); jp1.add(jb6);
170
171 jp1.add(jb[0]); jp1.add(jb[10]); jp1.add(jb[11]); jp1.add(jb7); jp1.add(jb8);
172
173 jp1.setLayout(new GridLayout(4,5,5,5));
174
175 //注册监听器
176
177 jb[10].addActionListener(this); jb[11].addActionListener(this);
178
179 jb1.addActionListener(this); jb2.addActionListener(this);
180
181 jb3.addActionListener(this); jb4.addActionListener(this);
182
183 jb5.addActionListener(this); jb6.addActionListener(this);
184
185 jb7.addActionListener(this); jb8.addActionListener(this);
186
187 //在容器上添加控件 //将面板添加到内容面板
188
189 c.add(jp2);
190
191 c.add(jp1);
192
193 c.add(jp3);
194
195 c.setLayout(new FlowLayout()); //设置为顺序布局
196
197 //初始化画框
198
199 setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);//关闭窗口不结束程序
200
201 setVisible(true); //设置为可见
202
203 //setResizable(false); //禁止调整框架大小
204
205 setSize(400,350); //设置窗口大小
206
207 }
208
209 //主方法实现创建一个窗口
210
211 public static void main(String[] args) {
212
213 counter f = new counter();
214
215 f.setBackground(Color.green);
216
217 }
218
219 //按钮的事件处理
220
221 public void actionPerformed(ActionEvent e) {
222
223 try
224
225 {
226
227 //选择"清零"按钮清零
228
229 if(e.getSource() == jb4) {
230
231 jt1.setText("0"); //把文本框清零
232
233 jt1.setHorizontalAlignment(JTextField.RIGHT); //文本对齐右边
234
235 str.setLength(0); //清空字符串缓冲区以准备接收新的输入运算数
236
237 }
238
239 //单击"+/-"选择输入的运算数是正数还是负数
240
241 else if(e.getSource() == jb[10]){
242
243 //trim函数作用是去掉字符串中的空格
244
245 //Double.parseDouble():将trim()后的词转换成双精度浮点数
246
247 x = Double.parseDouble(jt1.getText().trim());
248
249 jt1.setText("" + (-x));
250
251 jt1.setHorizontalAlignment(JTextField.RIGHT);
252
253 }
254
255 //单击加号按钮获得x的值和z的值并清空y的值
256
257 else if (e.getSource() == jb1) {
258
259 x = Double.parseDouble(jt1.getText().trim());
260
261 str.setLength(0);
262
263 y = 0d;
264
265 z = 0;
266
267 }
268
269 //单击减号按钮获得x的值和z的值并清空y的值
270
271 else if(e.getSource() == jb3) {
272
273 x = Double.parseDouble(jt1.getText().trim());
274
275 str.setLength(0);
276
277 y = 0d;
278
279 z = 1;
280
281 }
282
283 //单击乘号按钮获得x的值和z的值并清空y的值
284
285 else if(e.getSource() == jb5) {
286
287 x = Double.parseDouble(jt1.getText().trim());
288
289 str.setLength(0);
290
291 y = 0d;
292
293 z = 2;
294
295 }
296
297 //单击除号按钮获得x的值和z的值并清空y的值
298
299 else if(e.getSource() == jb7) {
300
301 x = Double.parseDouble(jt1.getText().trim());
302
303 str.setLength(0);
304
305 y=0d;
306
307 z=3;
308
309 }
310
311 //单击等号按钮输出计算结果
312
313 else if(e.getSource() == jb8) {
314
315 str.setLength(0);
316
317 switch(z) {
318
319 case 0:
320
321 jt1.setText(""+(x+y));
322
323 //设置计算结果水平向右对齐
324
325 jt1.setHorizontalAlignment(JTextField.RIGHT);
326
327 //设置字体样式和颜色
328
329 jt1.setFont(new Font("楷体",Font.BOLD,10));
330
331 jt1.setForeground(Color.blue);
332
333 break;
334
335 case 1:
336
337 jt1.setText(""+(x-y));
338
339 jt1.setHorizontalAlignment(JTextField.RIGHT);
340
341 jt1.setFont(new Font("楷体",Font.BOLD,10));
342
343 jt1.setForeground(Color.blue);
344
345 break;
346
347 case 2:
348
349 jt1.setText(""+(x*y));
350
351 jt1.setHorizontalAlignment(JTextField.RIGHT);
352
353 jt1.setFont(new Font("楷体",Font.BOLD,10));
354
355 jt1.setForeground(Color.blue);
356
357 break;
358
359 case 3:
360
361 jt1.setText(""+(x/y));
362
363 jt1.setHorizontalAlignment(JTextField.RIGHT);
364
365 jt1.setFont(new Font("楷体",Font.BOLD,10));
366
367 jt1.setForeground(Color.blue);
368
369 break;
370
371 }
372
373 }
374
375 //单击"."按钮输入小数
376
377 else if(e.getSource()==jb[11]) {
378
379 //判断字符串中是否已经包含了小数点
380
381 if(jt1.getText().trim().indexOf('.')!=-1) { }
382
383 //如果没有小数点
384
385 else {
386
387 //如果初始显示为0
388
389 if(jt1.getText().trim().equals("0")) {
390
391 jt1.setText(str.append(e.getActionCommand()).toString());
392
393 jt1.setHorizontalAlignment(JTextField.RIGHT);
394
395 }
396
397 //如果初始显示为空则不做任何操作
398
399 else if(jt1.getText().trim().equals("")) { }
400
401 else {
402
403 //append()方法:可以对字符，数字，字符串等数据类型的拼接，结果返回一个StringBuffer类型的对象,即str
404
405 //e.getActionCommand()方法依赖于按钮上的字符串
406
407 //toString()方法：返回反映这个对象的字符串
408
409 jt1.setText(str.append(e.getActionCommand()).toString());
410
411 jt1.setHorizontalAlignment(JTextField.RIGHT);
412
413 }
414
415 }
416
417 y=0d;
418
419 }
420
421 //求平方根
422
423 else if(e.getSource() == jb6) {
424
425 x=Double.parseDouble(jt1.getText().trim());
426
427 if(x<0) {
428
429 jt1.setText("数字格式异常");
430
431 jt1.setHorizontalAlignment(JTextField.RIGHT);
432
433 jt1.setForeground(Color.RED);
434
435 }
436
437 else {
438
439 double result = Math.sqrt(Double.valueOf(x));
440
441 jt1.setHorizontalAlignment(JTextField.RIGHT);
442
443 jt1.setFont(new Font("楷体",Font.BOLD,10));
444
445 jt1.setForeground(Color.blue);
446
447 }
448
449 str.setLength(0);
450
451 y=0d;
452
453 }
454
455 else {
456
457 //如果选择的是"0"这个数字键
458
459 if(e.getSource() == jb[0]){
460
461 //如果显示屏显示的为零不做操作
462
463 if(jt1.getText().trim().equals("0")) { }
464
465 else
466
467 jt1.setText(str.append(e.getActionCommand()).toString());
468
469 jt1.setHorizontalAlignment(JTextField.RIGHT);
470
471 y=Double.parseDouble(jt1.getText().trim());
472
473 }
474
475 //选择的是“←”键
476
477 else if (e.getSource() == jb2) {
478
479 //如果显示屏显示的不是零
480
481 if(!jt1.getText().trim().equals("0")) {
482
483 if(str.length()!=1) {
484
485 //可能抛出字符串越界异常
486
487 //delete()方法:将字符串从指定的start处开始，一直到索引end - 1处的字符
　　　　jt1.setText(str.delete(str.length()-1,str.length()).toString());
488
489 jt1.setHorizontalAlignment(JTextField.RIGHT);
490
491 }
492
493 else {
494
495 jt1.setText("0");
496
497 jt1.setHorizontalAlignment(JTextField.RIGHT);
498
499 str.setLength(0);
500
501 }
502
503 }
504
505 y=Double.parseDouble(jt1.getText().trim());
506
507 }
508
509 else {
510
511 jt1.setText(str.append(e.getActionCommand()).toString());
512
513 jt1.setHorizontalAlignment(JTextField.RIGHT);
514
515 y=Double.parseDouble(jt1.getText().trim());
516
517 }
518
519 }
520
521 }
522
523 catch(NumberFormatException e1){
524
525 jt1.setText("数字格式异常");
526
527 jt1.setHorizontalAlignment(JTextField.RIGHT);
528
529 jt1.setForeground(Color.RED);
530
531 }
532
533 catch(StringIndexOutOfBoundsException e1){
534
535 jt1.setText("字符串索引越界");
536
537 jt1.setHorizontalAlignment(JTextField.RIGHT);
538
539 jt1.setForeground(Color.RED);
540
541 }
542
543 save();
544
545 }
546
547 //保存
548
549 private void save() {
550
551 //利用流来输出到文件
552
553 FileOutputStream fos = null;
554
555 FileReader fr = null;
556
557 BufferedReader br = null;
558
559 String s = jt1.getText();
560
561 try {
562
563 fos = new FileOutputStream("D:\\java实训\\counter.txt");
564
565 //将字符串打散为一个字节数组
566
567 byte[] word = s.getBytes();
568
569 try {
570
571 fos.write(word);
572
573
574
575 //利用流读取文件到控制台
576
577 StringBuffer sb = new StringBuffer("");
578
579 fr = new FileReader("D:\\\\java实训\\\\counter.txt");
580
581 br = new BufferedReader(fr);
582
583
584
585 String line = null;
586
587 while((line = br.readLine()) != null) {
588
589 sb.append(line+"\n");
590
591 System.out.println(line);
592
593 }
594
595 } catch (IOException e) {
596
597 e.printStackTrace();
598
599 }
600
601 } catch (FileNotFoundException e) {
602
603 e.printStackTrace();
604
605 }finally {
606
607 try {
608
609 fos.close();
610
611 } catch (IOException e) {
612
613 e.printStackTrace();
614
615 }
616
617 }
618
619 }
620
621 }
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.
20.
21.
22.
23.
24.
25.
26.
27.
28.
29.
30.
31.
32.
33.
34.
35.
36.
37.
38.
39.
40.
41.
42.
43.
44.
45.
46.
47.
48.
49.
50.
51.
52.
53.
54.
55.
56.
57.
58.
59.
60.
61.
62.
63.
64.
65.
66.
67.
68.
69.
70.
71.
72.
73.
74.
75.
76.
77.
78.
79.
80.
81.
82.
83.
84.
85.
86.
87.
88.
89.
90.
91.
92.
93.
94.
95.
96.
97.
98.
99.
100.
101.
102.
103.
104.
105.
106.
107.
108.
109.
110.
111.
112.
113.
114.
115.
116.
117.
118.
119.
120.
121.
122.
123.
124.
125.
126.
127.
128.
129.
130.
131.
132.
133.
134.
135.
136.
137.
138.
139.
140.
141.
142.
143.
144.
145.
146.
147.
148.
149.
150.
151.
152.
153.
154.
155.
156.
157.
158.
159.
160.
161.
162.
163.
164.
165.
166.
167.
168.
169.
170.
171.
172.
173.
174.
175.
176.
177.
178.
179.
180.
181.
182.
183.
184.
185.
186.
187.
188.
189.
190.
191.
192.
193.
194.
195.
196.
197.
198.
199.
200.
201.
202.
203.
204.
205.
206.
207.
208.
209.
210.
211.
212.
213.
214.
215.
216.
217.
218.
219.
220.
221.
222.
223.
224.
225.
226.
227.
228.
229.
230.
231.
232.
233.
234.
235.
236.
237.
238.
239.
240.
241.
242.
243.
244.
245.
246.
247.
248.
249.
250.
251.
252.
253.
254.
255.
256.
257.
258.
259.
260.
261.
262.
263.
264.
265.
266.
267.
268.
269.
270.
271.
272.
273.
274.
275.
276.
277.
278.
279.
280.
281.
282.
283.
284.
285.
286.
287.
288.
289.
290.
291.
292.
293.
294.
295.
296.
297.
298.
299.
300.
301.
302.
303.
304.
305.
306.
307.
308.
309.
310.
311.
312.
313.
314.
315.
316.
317.
318.
319.
320.
321.
322.
323.
324.
325.
326.
327.
328.
329.
330.
331.
332.
333.
334.
335.
336.
337.
338.
339.
340.
341.
342.
343.
344.
345.
346.
347.
348.
349.
350.
351.
352.
353.
354.
355.
356.
357.
358.
359.
360.
361.
362.
363.
364.
365.
366.
367.
368.
369.
370.
371.
372.
373.
374.
375.
376.
377.
378.
379.
380.
381.
382.
383.
384.
385.
386.
387.
388.
389.
390.
391.
392.
393.
394.
395.
396.
397.
398.
399.
400.
401.
402.
403.
404.
405.
406.
407.
408.
409.
410.
411.
412.
413.
414.
415.
416.
417.
418.
419.
420.
421.
422.
423.
424.
425.
426.
427.
428.
429.
430.
431.
432.
433.
434.
435.
436.
437.
438.
439.
440.
441.
442.
443.
444.
445.
446.
447.
448.
449.
450.
451.
452.
453.
454.
455.
456.
457.
458.
459.
460.
461.
462.
463.
464.
465.
466.
467.
468.
469.
470.
471.
472.
473.
474.
475.
476.
477.
478.
479.
480.
481.
482.
483.
484.
485.
486.
487.
488.
489.
490.
491.
492.
493.
494.
495.
496.
497.
498.
499.
500.
501.
502.
503.
504.
505.
506.
507.
508.
509.
510.
511.
512.
513.
514.
515.
516.
517.
518.
519.
520.
521.
522.
523.
524.
525.
526.
527.
528.
529.
530.
531.
532.
533.
534.
535.
536.
537.
538.
539.
540.
541.
542.
543.
544.
545.
546.
547.
548.
549.
550.
551.
552.
553.
554.
555.
556.
557.
558.
559.
560.
561.
562.
563.
564.
565.
566.
567.
568.
569.
570.
571.
572.
573.
574.
575.
576.
577.
578.
579.
580.
581.
582.
583.
584.
585.
586.
587.
588.
589.
590.
591.
592.
593.
594.
595.
596.
597.
598.
599.
600.
601.
602.
603.
604.
605.
606.
607.
608.
609.
610.
611.
612.
613.
614.
615.
616.
617.
618.
619.
620.
621.
622.
 

3.2 文件设计
利用io流将成绩保存到文件中

4 系统实现

猜数游戏界面实现：

图4-1 猜数游戏运行界面

　　　　　　　　　　　　　　图4-2 猜数游戏保存界面

简易计算器运行界面：

　　　　　　图4-3 简易计算器图形界面

5 系统测试
在猜数游戏模块中主要对用户姓名以及参与人数的录入、猜数过程、排行榜的功能模块进行测试，测试结果如表5-1所示。

表5-1 猜数游戏模块测试表

编号

测试功能

输入描述

预期结果

运行结果

HP01

录入功能

1.用户姓名以及参与人数

2.生成随机数

可以正常录入以及生成要猜的数

正常，与预期结果一致

HP02

猜数功能

1.猜错提示猜大还是猜小

2.猜对则游戏结束

3.统计次数、记录时间

猜数过程正常进行，次数与时间记录成功

正常，与预期结果一致

HP03

排行榜

1.根据分数排序生成

显示排行榜

正常，与预期结果一致

猜数游戏模块测试主要是针对用户的操作，从测试结果中可以看出该模块的所有功能均能正常实现，且测试结果与预期结果一致。

在简易计算器模块中主要对运算数据、运算符号、清零退格、文本显示框、保存读取的功能模块进行测试，测试结果如表5-1所示。

表5-2 简易计算器模块测试表

编号

测试功能

输入描述

预期结果

运行结果

HP01

运算数据

1.实现0~9按钮

2.添加监听

3.显示在文本框

运算数据可以正常显示在文本框

正常，与预期结果一致

HP02

运算符号

1.实现+、-、*、/按钮

2.添加监听

3.显示在文本框

运算符号可以正常显示在文本框

正常，与预期结果一致

HP03

清零退格

实现清零、退格按钮
添加监听
文本框实现其功能
文本框正常显示清零与退格

正常，与预期结果一致

HP04

保存读取

1.根据io流实现保存、读取

保存到文件，读取到控制台

正常，与预期结果一致

简易计算器模块测试主要是针对用户的操作，从测试结果中可以看出该模块的所有功能均能正常实现，且测试结果与预期结果一致。

6 结论和心得
项目完成情况较好，过程比较艰辛，但收获也比较大。

心得：这次课程设计让我学到了很多东西，不仅仅丰富了我的理论知识，而且加强了我实践的能力。进行代码设计的同时，需要查阅大量的资料，学会查看帮助文档，遇到问题要主动向老师请教，又或是与同学交流，都是不错的选择。在这次实训中我们用到了好多之前学过的知识，需要我融会贯通，加以利用，设计出好的代码，在这当中我学到了新的内容，记录时间的方法，

long startTime = System.currentTimeMillis();
long endTime = System.currentTimeMillis();
1.
2.
GUI图形界面的实现，需要创建面板、标签、文本编辑框、按钮等组件，设计监听事件，使程序能够正常运行。我遇到最大的困难可能就是简易计算器保存读取功能的实现，耗费了很长时间，经历了代码多次修改，最终还算是有一个差不多的结果。下一阶段的任务，更需要认真、坚持，多动手实践。