JAVA大作业 欢乐五子棋 源码+实验报告（可直接运行）

Java程序设计

大作业报告

题目： 欢乐五子棋

学院： 软件学院

姓名：

学号：

专业班级：

任课教师：

截止时间： 2022年6月11日

大作业要求：

请根据本学期所学的Java和面向对象的思想实现一个完整的系统。开发环境和工具不限，大作业题目和内容自定，代码总行数不低于800行（含注释）。鼓励围绕这次疫情期间产生的学习、生活、工作的需求来开发相应程序。

具体要求如下：

1. 采用面向对象程序设计，要运用继承、多态等机制；
2. 代码规范需遵循Java编码规范要求；
3. 具备文件读写功能，程序中的数据要以文件方式保存；
4. 程序中要求具备异常处理；
5. 使用第三方类库或者插件需在报告和程序中注明来源和版权信息，并详细说明使用了该第三方类库或者插件哪部分功能。
6. 要求具备菜单功能，根据用户的输入，执行相应的操作。在菜单选项中，必须包含“关于”一项，该菜单项用来显示本作业的基本信息，包括程序名称、版本、完成时间，姓名、学号、班级等信息；
7. 程序要求做到界面友好，对于用户的输入操作要有明确的提示信息，并对输入的数据进行合法性和正确性的检查；
8. 每个文件、类、方法的前面都必须有规范的注释，注释中要说明作者是谁、主要功能、编写时间等信息。变量、常量、关键语句等都必须有注释说明。
9. 所有源程序代码(含注释)都要拷贝到大作业报告的【3.3 程序实现】中。
10. 源代码为多文件项目，合理分配好各个源代码文件内容。
11. 本报告文档是作业的一个重要内容，文档中的每个内容都必须认真按照要求撰写，否则扣分。

---

模板格式说明：

1. 正文模板中的红色文字部分为说明文字，请仔细阅读后撰写正式的内容。
2. 排版要求：

页面设置：上2.54cm，下2.54cm，左3.67cm，右2.67cm，页眉1.5cm,页脚1.75cm，行间距1.35倍。

全文中文字体采用宋体，英文字体采用Times New Roman字体，一级标题使用小三号字体，二级、三级标题均使用四号字体，正文内容采用小四号字体，代码字体大小为五号。

目 录

一、需求分析1

1.1、开发环境1

1.2、功能需求1

二、系统分析与设计1

2.1、本程序需解决的关键技术问题1

2.2、总体功能图1

2.3、类图2

2.4、程序流程图（至少画1个关键性功能的流程图）2

三、程序设计与实现2

3.1、项目文件组织结构2

3.2、程序设计3

3.3、程序实现3

四、系统测试3

五、本程序高内聚低耦合的特点，易扩展、易维护3

六、总结与体会4

七、自评分4

1. 需求分析

1.1、开发环境

操作系统及版本：win 10

开发工具及版本：IntelliJ IDEA Educational Edition 2021.3.2

1.2、功能需求

欢乐五子棋

1. 设置程序只能在限定的棋盘上落子，开始游戏后，当鼠标在棋盘上点击时，绘制棋子
2. 完成五子棋的基本规则——任一方先在棋盘上形成横向、竖向、斜向的连续的相同颜色的五个(含五个以上)棋子的一方为胜，结束游戏。
3. 设置倒计时功能，单位为分钟，令游戏更加合理
4. 设置悔棋功能，防止因一些客观原因落子失败
5. 设置认输功能
6. 设置历史对局功能，查看历史对局输赢情况
7. 设置退出功能
8. 系统分析与设计
   2.1、本程序需解决的关键技术问题
   1、如何令鼠标在限定的范围内落子而不越界
   2、如何实现黑子白子轮流进行落子
   3、如何实现任一种颜色棋子在任意方向上练成五个时判定某一方胜利
   4、如何令菜单上的功能在规定的点击范围内响应
   5、如何令棋子落在棋盘的网格线上且当两个棋子选择下在同一个网格上时，怎样解决上一个棋子被覆盖的问题
   6、怎样完成时间的设置，并且当使用者输入正整数和0以外的数字使不产生bug
   7、如何将对局输赢情况（包含时间线）存储在文件中不出现bug，以及如何将对局内容呈现在窗口中
   2.2、总体功能图

2.3、类图

2.4、程序流程图（至少画1个关键性功能的流程图）

函数：paint函数，MyFrameChess函数，mousePressed函数，judge函数，run函数

1. 程序设计与实现

3.1、项目文件组织结构

3.2、程序设计

mainmenu类：用于调用MyFrameChess类

MyFrameChess类：用于构建棋盘，控制落子，判断胜负，设置时间等功能

关键知识点：继承，封装，多态，多线程运行，JFrame和鼠标监听器的相关知识

主要成员函数：

MyFrameChess构造函数：初始化相关变量

paint函数：用于设置界面，包括背景图片的导入，棋盘的绘制，落子方的提示信息。

mousePressed函数：

设计意图：监听鼠标位置，实现棋盘上各项功能

功能：获取x,y的坐标，根据由paint函数记录的数据绘制棋子，判断游戏是否结束。

实现“开始游戏”选项，点击重新开始，清空棋盘，开始游戏

实现“倒计时”选项，以分钟为单位设置时间，输入数为0时，设置时间无限制

实现“游戏说明”选项，点击游戏说明，弹出对话框以介绍游戏规则

实现“关于”选项，点击关于，弹出对话框介绍游戏制作相关内容

实现“悔棋”选项，点击悔棋，撤回上一步，但不可连续重复执行

实现“认输”选项，点击认输，判断当前落子的人败北，游戏结束

实现“历史对局”选项，点击显示历史对局的输赢情况

实现“退出游戏”选项，点击退出，结束程序

judge函数： 用于判断当前落子位置是否存在其余四个相同颜色棋子使当前一方连成五子

run函数： 用于实现多线程运作

3.3、程序实现

paint函数：利用鼠标监听器获取棋盘的范围，再通过for循环划出棋盘，同时使用Graphics类对界面进行相应优化

MyFrameChess构造函数：主要用于初始化各个变量

mousePressed函数：使用if函数进行各类判断确定各类功能作用范围，利用JFrame的弹窗设置各类提示信息，显示时间maxtime本是正整数，运用一些方法设置为时分秒的形式，代码如下：

1. if(maxTime > 0){
2. bTime = maxTime/3600+":"+
3. (maxTime/60-maxTime/3600*60)+
4. ":"+(maxTime-maxTime/60*60);
5. wTime = maxTime/3600+
6. ":"+(maxTime/60-maxTime/3600*60)+
7. ":"+(maxTime-maxTime/60*60);

悔棋选项利用记录最后落子坐标的方法进行撤回，代码如下：

1. //设置悔棋选项
2. //限定选项范围
3. if(e.getX()>=505&&e.getX()<=598&&e.getY()>=280&&e.getY()<=320){
4. //判断当前棋盘上是否有棋子
5. if(allchess[finalx][finaly]!=0&&Goon==true){
6. //弹出选择对话框，根据选项决定是否执行悔棋程序
7. int result = JOptionPane.showConfirmDialog(this,
8. "请问是否进行悔棋操作？");
9. //若选择坚持执行悔棋程序，则进行以下操作
10. if(result == 0){
11. //将最后一步的棋子设置为无，即清除该点的棋子
12. allchess[finalx][finaly] = 0;
13. //返回到落子前的棋盘状态
14. if(Black == true){
15. //若悔棋时是黑子，则将棋子颜色设置为白色
16. Black = false;
17. //将游戏信息变换为对应的内容
18. message = "轮到白方";
19. }else{
20. //若悔棋时是黑子，则将棋子颜色设置为黑色
21. Black = true;
22. //将游戏信息变换为对应的内容
23. message = "轮到黑方";
24. }
25. //重绘棋盘
26. this.repaint();
27. }
28. }else{
29. //若棋盘上无棋子或连续执行悔棋操作，则弹出该窗口
30. JOptionPane.showMessageDialog(this,"无效操作！");
31. }
32. }

judge函数：设置判断五子是否相连的方法

若存在相同颜色的五个棋子任意方向相连，则返回true值

该类的算法判断依据为：

每落子一次便进行判定一次

当判定当前棋子周围任意一个方向上有相同颜色棋子相连时

则设置改棋子为最后落的棋子，将结束游戏条件设置为true

部分代码如下：

1. //初始化为不相连
2. boolean flag = false;
3. //记录相同颜色棋子相连的数量
4. int count = 1;
5. //将本轮下的棋子颜色作为参考颜色
6. int color = allchess[x][y];
7. //用于判断横向是否有五个棋子相连
8. int one = 1;
9. //首先判断横向右方的棋子情况
10. //防止向右越界异常处理
11. while(x+one>=0&&x+one<=18&&
12. y>=0&&y<=18&&
13. color == allchess[x+one][y]){
14. //若横向右方有相同颜色的棋子，则计数加一
15. count++;
16. //判断范围再往右前进一格
17. one++;
18. }
19. //将判断范围初始化
20. one = 1;
21. //判断横向左方的棋子情况
22. //防止向左越界异常处理
23. while(x-one>=0&&x-one<=18&&
24. y>=0&&y<=18&&
25. color == allchess[x-one][y]){
26. //若横向左方有相同颜色的棋子，则计数加一
27. count++;
28. //判断范围再往左前进一格
29. one++;
30. }
31. //若相同连续的棋子计数达到五个，则更改flag的值
32. if(count >= 5){
33. //使上层判定游戏结束，其中一方获得胜利
34. flag = true;
35. }

run函数：设置倒计时使黑方与白方时间各独立一个线程，当一方落子时，另一方的线程继续开始，设定每一秒时间某一方时间减一，当某一方时间为0时，停止计时，设置时间为-1，代表游戏结束

代码如下：

1. public void run() {
2. //当设置时间大于0时，程序才会开始
3. if(maxTime>0){
4. //设置程序一直运行
5. while(true){
6. //设置黑方时间减少
7. if(Black){
8. //当黑方时间大于0时，设置黑方时间每秒减一
9. if(BTime > 0){
10. BTime--;
11. }
12. //黑方游戏时间耗尽时，判断游戏结束
13. if(BTime == 0){
14. JOptionPane.showMessageDialog(this,"黑方超时，游戏结束！");
15. Goon = false;
16. //当黑方时间等于0时，设置时间为-1，防止倒计时继续运转
17. BTime = -1;
18. }
19. }else{
20. if(WTime > 0){
21. //设置白方时间每秒减一
22. WTime--;
23. }
24. if(WTime == 0){
25. //白方游戏时间耗尽时，判断游戏结束
26. JOptionPane.showMessageDialog(this,"白方超时，游戏结束！");
27. Goon = false;
28. WTime = -1;
29. }
30. }
31. //设置黑方显示时间为时分秒的显示形式
32. bTime = BTime/3600+":"+
33. (BTime/60-BTime/3600*60)+":"+
34. (BTime-BTime/60*60);
35. //设置白方显示时间为时分秒的显示形式
36. wTime = WTime/3600+":"+
37. (WTime/60-WTime/3600*60)+":"+
38. (WTime-WTime/60*60);
39. //重绘棋盘，刷新时间
40. this.repaint();
41. try {
42. //设置停顿
43. Thread.sleep(1000);
44. } catch (InterruptedException e) {
45. e.printStackTrace();
46. }
47. //System.out.println(BTime+"---"+WTime);
48. }
49. }
50. }

项目源代码如下：

Mainmenu.java：

1. package FiveChessGame;
2. //项目名称：欢乐五子棋
3. //期望分数：93
4. //理由：界面设计合理，功能齐全，具有一定的创新性
5. //该类用于调用MyFrameChess函数
6. public class mainmenu {
7. public static void main(String[] args) {
8. //创建MyFrameChess类对象
9. MyFrameChess zby = new MyFrameChess();
10. }
11. }

MyFrameChess.java：

1. package FiveChessGame;
2. import javax.imageio.ImageIO;
3. import javax.swing.*;
4. import java.awt.*;
5. import java.awt.event.MouseEvent;
6. import java.awt.event.MouseListener;
7. import java.awt.image.BufferedImage;
8. import java.io.File;
9. import java.io.IOException;
10. import java.util.ArrayList;
11. //MyFrameChess类
12. //主要功能包括绘制棋盘，实现游戏各项功能，设置时间限制等
13. //实现游戏主体功能
14. public class MyFrameChess extends JFrame implements MouseListener,Runnable {
15. //定义图片
16. BufferedImage image = null;
17. //定义x坐标，y坐标
18. int x = 0;
19. int y = 0;
20. //记录步数
21. int step = 0;
22. //记录最后下的棋子的横坐标
23. int finalx = 0;
24. //记录最后下的棋子的纵坐标
25. int finaly = 0;
26. //创建菜单栏
27. private JMenuBar menuBar;
28. //添加系统
29. private JMenu sysMenu;
30. //添加开始选项
31. private JMenuItem startMenuItem;
32. //添加悔棋选项
33. private JMenuItem backMenuItem;
34. //添加退出选项
35. private JMenuItem exitMenuItem;
36. // //添加相关按钮
37. // private JPanel toolBar;
38. //
39. // //添加开始按钮
40. // private JButton startButton;
41. //
42. // //添加悔棋按钮
43. // private JButton backButton;
44. //
45. // //添加退出按钮
46. // private JButton exitButton;
47. //保存之前下过棋子的全部坐标,0表示没有棋子，1表示黑子，2表示白子
48. int[][] allchess = new int[19][19];
49. //判断要下的棋子颜色
50. boolean Black = true;
51. //判断游戏是否需要进行
52. boolean Goon = false;
53. //提供一些必要的游戏提示信息
54. String message = "黑方先行";
55. //设置最大时间
56. int maxTime = 0;
57. //倒计时的线程类
58. Thread time = new Thread(this);
59. //设置黑方和白方的剩余时间
60. int BTime = 0;
61. int WTime = 0;
62. //设置黑方和白方的剩余显示时间
63. String bTime = "无限制";
64. String wTime = "无限制";
65. ResultManager resultManager = new ResultManager();
66. //MyFrameChess类的构造方法
67. //用于初始化棋盘，各类按键，设置背景图片，控制落子
68. public MyFrameChess(){
69. //取得屏幕的宽度
70. int width = Toolkit.getDefaultToolkit().getScreenSize().width;
71. //取得屏幕的高度
72. int height = Toolkit.getDefaultToolkit().getScreenSize().height;
73. // toolBar = new JPanel();
74. //
75. // startButton = new JButton();
76. //
77. // backButton = new JButton();
78. //
79. // exitButton = new JButton();
80. //初始化菜单栏
81. menuBar = new JMenuBar();
82. //初始化系统
83. sysMenu = new JMenu("系统");
84. //初始化开始选项
85. startMenuItem = new JMenuItem("开始游戏");
86. //初始化悔棋选项
87. backMenuItem = new JMenuItem("悔棋");
88. //初始化退出选项
89. exitMenuItem = new JMenuItem("退出");
90. //将菜单栏添加到页面中
91. this.setJMenuBar(menuBar);
92. //将系统添加到菜单栏中
93. menuBar.add(sysMenu);
94. //将开始选项添加到系统中
95. sysMenu.add(startMenuItem);
96. //将悔棋选项添加到系统中
97. sysMenu.add(backMenuItem);
98. //将退出选项添加到系统中
99. sysMenu.add(exitMenuItem);
100. //设置标题
101. this.setTitle("欢乐五子棋");
102. //设置界面大小
103. this.setSize(620,700);
104. //设置界面出现在屏幕中间
105. this.setLocation((width-500)/2,(height-500)/2);
106. //设置为大小不可改变，以防止嵌入的图片出现问题
107. this.setResizable(false);
108. //设置关闭窗口后程序结束
109. this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
110. //设置窗口可见
111. this.setVisible(true);
112. //添加鼠标监听器
113. this.addMouseListener(this);
114. //设置线程设置
115. time.start();
116. //将线程暂时悬挂
117. time.suspend();
118. //解决黑屏的情况
119. this.repaint();
120. try {
121. //导入图片
122. image = ImageIO.read(new File("f:/Java大作业/background1.jpg"));
123. // File background = new File("F:\\Java大作业\\background1.jpg");
124. // System.out.println(background.getPath());
125. // image = ImageIO.read(background);
126. } catch (IOException e) {
127. e.printStackTrace();
128. }
129. }
130. //该类用于设置界面
131. public void paint(Graphics show){
132. //设置图片出现位置
133. show.drawImage(image,0,30,null);
134. //设置字体
135. show.setFont(new Font("黑体",Font.BOLD,20));
136. //在右上角设置落子方提示信息
137. show.drawString(message,500,65);
138. //重新设置字体，增加悔棋按键
139. show.setFont(new Font("黑体",Font.BOLD,25));
140. //在棋盘的右方增加悔棋按键
141. show.drawString("悔棋",520,300);
142. //重新设置字体
143. show.setFont(new Font("宋体",0,20));
144. //在棋盘的下方设置显示时间
145. show.drawString("黑方时间:"+bTime,40,600);
146. show.drawString("白方时间:"+wTime,260,600);
147. //绘制悔棋按键的边框
148. show.drawOval(510,265,70,50);
149. //绘制棋盘
150. for(int i = 0;i < 20;i++){
151. //绘制横线
152. show.drawLine(25,82+i*25,499,82+i*25);
153. //绘制竖线
154. show.drawLine(25+i*25,82,25+i*25,556);
155. }
156. //标注点位
157. show.fillOval(98,155,5,5);
158. show.fillOval(98,480,5,5);
159. show.fillOval(424,155,5,5);
160. show.fillOval(424,480,5,5);
161. //标注中心点位
162. show.fillOval(274,305,5,5);
163. show.fillOval(274,480,5,5);
164. show.fillOval(98,305,5,5);
165. show.fillOval(424,305,5,5);
166. show.fillOval(274,155,5,5);
167. //控制棋盘的落子
168. for(int i = 0;i < 19;i ++){
169. for(int j = 0;j < 19;j ++){
170. //读取二维数组中记录的各类棋子的位置
171. if(1 == allchess[i][j]){
172. //绘制黑子
173. int X = i*25+25;
174. int Y = j*25+82;
175. //使棋子落在网格线的交叉处
176. show.fillOval(X-7,Y-7,15,15);
177. }
178. if(2 == allchess[i][j]){
179. int X = i*25+25;
180. int Y = j*25+82;
181. //将画笔颜色设置为白色
182. show.setColor(Color.white);
183. //绘制白色棋子
184. show.fillOval(X-7,Y-7,15,15);
185. show.setColor(Color.black);
186. //绘制黑色边框
187. show.drawOval(X-7,Y-7,15,15);
188. }
189. }
190. }
191. }
192. @Override
193. public void mouseClicked(MouseEvent e) {
194. }
195. @Override
196. //该类的功能主要通过监听实现，包括获取鼠标位置，绘制棋子，以及实现棋盘上的各类选项
197. public void mousePressed(MouseEvent e) {
198. //首先判定游戏是否在进行中
199. if (Goon == true) {
200. //获取鼠标位置信息
201. x = e.getX();
202. y = e.getY();
203. //使棋子落在棋盘上
204. if (x >= 25 && x <= 498 && y >= 82 && y <= 556) {
205. //得到距离鼠标位置最近的网格交叉点的坐标
206. x = (x - 25) / 25;
207. y = (y - 82) / 25;
208. //将当前所下的棋子的x坐标记录下来
209. finalx = x;
210. //将当前所下的棋子的y坐标记录下来
211. finaly = y;
212. //设置步数加一
213. step++;
214. //设置落子判断条件，防止棋子被覆盖
215. if (allchess[x][y] == 0) {
216. //若当前回合由黑方落子，则在棋盘相应位置绘制黑子
217. if (Black == true) {
218. //记录当前黑子的位置信息
219. allchess[x][y] = 1;
220. //转换棋子颜色
221. Black = false;
222. //更改回合提示信息
223. message = "轮到白方";
224. } else {
225. //记录当前白子的位置信息
226. allchess[x][y] = 2;
227. //转换棋子颜色
228. Black = true;
229. //更改回合提示信息
230. message = "轮到黑方";
231. }
232. //判断胜利条件，设置游戏不可运行
233. boolean win = this.judge();
234. //判断游戏胜利方
235. //若win为true，则执行游戏结束
236. //若win为false，则继续游戏
237. if (win == true) {
238. if (allchess[x][y] == 1) {
239. JOptionPane.showMessageDialog(this, "游戏结束,黑方获胜");
240. try {
241. resultManager.writeResult("游戏结束，黑方获胜");
242. } catch (IOException ioException) {
243. ioException.printStackTrace();
244. }
245. //FileOutputStream fos2 = new FileOutputStream( new File(pathname:"1111\\fos.txt"));
246. } else {
247. JOptionPane.showMessageDialog(this, "游戏结束,白方获胜");
248. try {
249. resultManager.writeResult("游戏结束，白方获胜");
250. } catch (IOException ioException) {
251. ioException.printStackTrace();
252. }
253. }
254. //设置游戏结束
255. Goon = false;
256. }
257. //判断当前所下位置是否有棋子，防止棋子被覆盖
258. } else {
259. JOptionPane.showMessageDialog(this, "当前位置已有棋子，请重下");
260. }
261. //重绘棋盘
262. this.repaint();
263. }
264. }
265. //开始游戏选项
266. //限定功能范围
267. if(e.getX()>=505&&e.getX()<=598&&e.getY()>=75&&e.getY()<=125){
268. int result = JOptionPane.showConfirmDialog(this,"是否重新开始游戏？");
269. if(result == 0){
270. Goon = true;
271. //清空棋盘，回到初始状态
272. for(int i = 0;i < 19;i++){
273. for(int j = 0;j < 19;j++){
274. allchess[i][j] = 0;
275. }
276. }
277. //清空初始信息
278. message = "黑方先行";
279. Black = true;
280. //重新设置游戏时间
281. BTime = maxTime;
282. WTime = maxTime;
283. //将显示时间设置为时、分、秒的形式
284. if(maxTime > 0){
285. bTime = maxTime/3600+":"+
286. (maxTime/60-maxTime/3600*60)+
287. ":"+(maxTime-maxTime/60*60);
288. wTime = maxTime/3600+
289. ":"+(maxTime/60-maxTime/3600*60)+
290. ":"+(maxTime-maxTime/60*60);
291. //重启线程
292. time.resume();
293. //当输入时间为0时设置时间为无限制
294. }else if(maxTime == 0){
295. bTime = "无限制";
296. wTime = "无限制";
297. }
298. this.repaint();
299. }
300. }
301. //设置游戏设置选项
302. //限定选项作用范围
303. if(e.getX()>=505&&e.getX()<=598&&e.getY()>=145&&e.getY()<=195){
304. //获取最大游戏时长
305. String timeSet = JOptionPane.showInputDialog("请输入游戏的最大时间（分钟）:");
306. try {
307. //强制将timeSet转为int形式
308. maxTime = Integer.parseInt(timeSet)*60;
309. //防止游戏时长输入为负数
310. if(maxTime<0){
311. JOptionPane.showMessageDialog(this,"请输入正确格式的信息！");
312. }
313. //设置游戏时长无限制
314. if(maxTime == 0) {
315. int result = JOptionPane.showConfirmDialog(this, "设置完成，是否重新开始游戏？");
316. //游戏时长设置后需重新开始游戏
317. if (result == 0) {
318. Goon = true;
319. for (int i = 0; i < 19; i++) {
320. for (int j = 0; j < 19; j++) {
321. //清空棋盘
322. allchess[i][j] = 0;
323. }
324. }
325. //初始化信息
326. message = "黑方先行";
327. //重新加载剩余时间
328. BTime = maxTime;
329. WTime = maxTime;
330. //重新加载显示时间
331. bTime = "无限制";
332. wTime = "无限制";
333. //将该回合落子设定为黑子
334. Black = true;
335. //重绘棋盘
336. this.repaint();
337. }
338. }
339. //添加游戏时长大于0时的相关功能
340. if(maxTime > 0){
341. //重启游戏
342. Goon = true;
343. time.resume();
344. for(int i = 0;i < 19;i++){
345. for(int j = 0;j < 19;j++){
346. allchess[i][j] = 0;
347. }
348. }
349. message = "黑方先行";
350. Black = true;
351. //重新加载剩余时间
352. BTime = maxTime;
353. WTime = maxTime;
354. //设置游戏时长显示格式
355. bTime = maxTime/3600+
356. ":"+(maxTime/60-maxTime/3600*60)+
357. ":"+(maxTime-maxTime/60*60);
358. wTime = maxTime/3600+
359. ":"+(maxTime/60-maxTime/3600*60)+
360. ":"+(maxTime-maxTime/60*60);
361. //重绘棋盘
362. this.repaint();
363. }
364. //异常处理，防止输入错误字符
365. } catch (NumberFormatException numberFormatException) {
366. JOptionPane.showMessageDialog(this,"请输入正确格式的信息！");
367. }
368. }
369. //设置游戏说明选项
370. //限定选项作用范围
371. if(e.getX()>=505&&e.getX()<=598&&e.getY()>=215&&e.getY()<=265){
372. //介绍游戏的相关信息以及游戏玩法
373. JOptionPane.showMessageDialog(this,"五子棋游戏。\n" +
374. "游戏规则：\n"+
375. "黑白双方依次落子，由黑先下\n"+
376. "任一方先在棋盘上形成横向、竖向、斜向的连续的相同颜色的五个(含五个以上)棋子的一方为胜。\n"+
377. "若在规定时间内都没有一方能够连成五个（或以上）棋子，则判定先用完时间的一方失败。\n"+
378. "开始游戏选项：\n"+
379. "点击开始游戏选项以开始游戏，否则无法开始游戏。\n"+
380. "倒计时选项：\n"+
381. "点击游戏设置选项以完成时间的设置.\n"+
382. "时间设置单位为分钟，且仅支持输入0和正整数。\n"+
383. "当输入时间为0时，设置双方时间为无限制。\n"+
384. "时间设置完毕后若开始游戏，则会清空当前棋盘，请玩家留意。\n"+
385. "时间设置完毕后，会在棋盘下方显示剩余时间，双方起始剩余时间相同。\n"+
386. "游戏从黑方开始倒计时，若黑方落子，则开始扣除白方的剩余时间，反之亦然。\n"+
387. "认输选项：\n"+
388. "点击认输选项会直接结束游戏，判定当前落子的一方败北。\n"+
389. "使用前还请认真考虑。\n"+
390. "关于选项：\n"+
391. "点击关于选项会给出制作人员以及该程序的相关信息。\n"+
392. "退出选项：\n"+
393. "点击退出选项会直接结束掉程序，使用前请认真考虑。\n"+
394. "历史对局选项：\n"+
395. "点击查看历史对局结果。\n"+
396. "悔棋选项：\n"+
397. "点击悔棋选项可以撤销上一回合的落子，且有该方重新落子。\n"+
398. "点击悔棋后时间不会回复到之前的状态，且悔棋选项不可以连续使用。\n"+
399. "若点击悔棋时棋盘上并未有落子，则会提示无效操作。\n"+
400. "悔棋选项可能会破坏游戏的公平性，使用前请慎重.\n"
401. );
402. }
403. //设置游戏认输选项
404. //限定选项作用范围
405. if(e.getX()>=505&&e.getX()<=598&&e.getY()>=335&&e.getY()<=385){
406. //设置选择对话框
407. int result = JOptionPane.showConfirmDialog(this,"请问您是否确定认输？");
408. //根据判断结果决定是否判定认输
409. if(result == 0) {
410. //判断认输方
411. if (Black == true) {
412. //若该回合为黑方落子，则判定白方获胜
413. JOptionPane.showMessageDialog(this, "黑方认输，白方获得胜利！");
414. //FileOutputStream his =new FileOutputStream( name: "黑方认输，白方获胜\\his.txt");
415. // File file =new File( pathname:"黑方认输，白方获胜\\his.txt");
416. // FileOutputStream fos2 =new FileOutputStream(file);
417. try {
418. resultManager.writeResult("黑方认输，白方获胜");
419. } catch (IOException ioException) {
420. ioException.printStackTrace();
421. }
422. } else {
423. //若该回合为白方落子，则判定黑方获胜
424. JOptionPane.showMessageDialog(this, "白方认输，黑方获得胜利！");
425. try {
426. resultManager.writeResult("白方认输，黑方获胜");
427. } catch (IOException ioException) {
428. ioException.printStackTrace();
429. }
430. }
431. //设置游戏结束
432. Goon = false;
433. }
434. }
435. //设置游戏关于选项
436. //限定选项范围
437. if(e.getX()>=505&&e.getX()<=598&&e.getY()>=410&&e.getY()<=455){
438. //介绍作者以及游戏的相关信息
439. JOptionPane.showMessageDialog(this,"程序名称：欢乐五子棋\n"+
440. "版本信息：欢乐五子棋2.0\n"+
441. "完成时间：2022.06.05\n" +
442. "姓名：\n" +
443. "学号：\n" +
444. "班级：班\n");
445. }
446. //设置历史对局选项
447. //限定选项范围
448. if(e.getX()>=505&&e.getX()<=598&&e.getY()>=490&&e.getY()<=535){
449. // 查看文件中的历史对局记录
450. ArrayList resultList;
451. String result = "";
452. try {
453. resultList = resultManager.readResult();
454. for(Object obj : resultList){
455. result += obj.toString();
456. }
457. } catch (IOException ioException) {
458. ioException.printStackTrace();
459. }
460. //弹出游戏历史对局对话框
461. JOptionPane.showMessageDialog(this,result);
462. }
463. //设置退出选项
464. //限定选项范围
465. if(e.getX()>=505&&e.getX()<=598&&e.getY()>=570&&e.getY()<=615){
466. //弹出游戏结束对话框
467. JOptionPane.showMessageDialog(this,"游戏结束！");
468. //退出程序
469. System.exit(0);
470. }
471. //设置悔棋选项
472. //限定选项范围
473. if(e.getX()>=505&&e.getX()<=598&&e.getY()>=280&&e.getY()<=320){
474. //判断当前棋盘上是否有棋子
475. if(allchess[finalx][finaly]!=0&&Goon==true){
476. //弹出选择对话框，根据选项决定是否执行悔棋程序
477. int result = JOptionPane.showConfirmDialog(this,
478. "请问是否进行悔棋操作？");
479. //若选择坚持执行悔棋程序，则进行以下操作
480. if(result == 0){
481. //将最后一步的棋子设置为无，即清除该点的棋子
482. allchess[finalx][finaly] = 0;
483. //返回到落子前的棋盘状态
484. if(Black == true){
485. //若悔棋时是黑子，则将棋子颜色设置为白色
486. Black = false;
487. //将游戏信息变换为对应的内容
488. message = "轮到白方";
489. }else{
490. //若悔棋时是白子，则将棋子颜色设置为黑色
491. Black = true;
492. //将游戏信息变换为对应的内容
493. message = "轮到黑方";
494. }
495. //重绘棋盘
496. this.repaint();
497. }
498. }else{
499. //若棋盘上无棋子或连续执行悔棋操作，则弹出该窗口
500. JOptionPane.showMessageDialog(this,"无效操作！");
501. }
502. }
503. }
504. //设置判断五子是否相连的方法
505. //若存在相同颜色的五个棋子任意方向相连，则返回true值
506. //该类的算法判断依据为：
507. //每落子一次便进行判定一次
508. //当判定当前棋子周围任意一个方向上有相同颜色棋子相连时
509. //则设置改棋子为最后落的棋子，将结束游戏条件设置为true
510. private boolean judge(){
511. //初始化为不相连
512. boolean flag = false;
513. //记录相同颜色棋子相连的数量
514. int count = 1;
515. //将本轮下的棋子颜色作为参考颜色
516. int color = allchess[x][y];
517. //用于判断横向是否有五个棋子相连
518. int one = 1;
519. //首先判断横向右方的棋子情况
520. //防止向右越界异常处理
521. while(x+one>=0&&x+one<=18&&
522. y>=0&&y<=18&&
523. color == allchess[x+one][y]){
524. //若横向右方有相同颜色的棋子，则计数加一
525. count++;
526. //判断范围再往右前进一格
527. one++;
528. }
529. //将判断范围初始化
530. one = 1;
531. //判断横向左方的棋子情况
532. //防止向左越界异常处理
533. while(x-one>=0&&x-one<=18&&
534. y>=0&&y<=18&&
535. color == allchess[x-one][y]){
536. //若横向左方有相同颜色的棋子，则计数加一
537. count++;
538. //判断范围再往左前进一格
539. one++;
540. }
541. //若相同连续的棋子计数达到五个，则更改flag的值
542. if(count >= 5){
543. //使上层判定游戏结束，其中一方获得胜利
544. flag = true;
545. }
546. //初始化计数
547. count = 1;
548. //纵向判断范围初始化
549. int two = 1;
550. //判断纵向上方的棋子情况
551. //防止向上越界异常处理
552. while(x>=0&&x<=18&&y+two>=0&&y+two<=18&&
553. color == allchess[x][y+two]){
554. //若纵向上方有相同颜色的棋子，则计数加一
555. count++;
556. //判断范围向上前进一格
557. two++;
558. }
559. //重置判断范围
560. two = 1;
561. //判断纵向下方的棋子情况
562. //防止向下越界异常处理
563. while(x>=0&&x<=18&&y-two>=0&&y-two<=18&&
564. color == allchess[x][y-two]){
565. //若纵向下方有相同颜色的棋子，则计数加一
566. count++;
567. //判断范围向下前进一格
568. two++;
569. }
570. //若相同连续的棋子计数达到五个，则更改flag的值
571. if(count >= 5){
572. //判定条件改为true
573. flag = true;
574. }
575. //初始化计数
576. count = 1;
577. //左上、右下判断初始化
578. int three = 1;
579. //判断右下方的棋子情况
580. //防止右下越界异常处理
581. while(x+three>=0&&x+three<=18&&y+three>=0&&y+three<=18&&
582. color == allchess[x+three][y+three]){
583. //若右下方有相同颜色的棋子，则计数加一
584. count++;
585. //判断范围向右下前进一格
586. three++;
587. }
588. //重置判断范围
589. three = 1;
590. //判断左上方的棋子情况
591. //防止左上方越界异常处理
592. while(x-three>=0&&x-three<=18&&y-three>=0&&y-three<=18&&
593. color == allchess[x-three][y-three]){
594. //若左上方有相同颜色的棋子，则计数加一
595. count++;
596. //判断范围向左上方前进一格
597. three++;
598. }
599. //若相同连续的棋子计数达到五个，则更改flag的值
600. if(count >= 5){
601. flag = true;
602. }
603. //重置判断范围
604. count = 1;
605. //右上、左下判断初始化
606. int four = 1;
607. //判断右上方的棋子情况
608. //防止右上方越界异常处理
609. while(x+four>=0&&x+four<=18&&y-four>=0&&y-four<=18&&
610. color == allchess[x+four][y-four]){
611. //若右上方有相同颜色的棋子，则计数加一
612. count++;
613. //判断范围向右上方前进一格
614. four++;
615. }
616. //重置判断范围
617. four = 1;
618. //判断左下方的棋子情况
619. //防止左下方越界异常处理
620. while(x-four>=0&&x-four<=18&&y+four>=0&&y+four<=18&&
621. color == allchess[x-four][y+four]){
622. //若左下方有相同颜色的棋子，则计数加一
623. count++;
624. //判断范围向左下方前进一格
625. four++;
626. }
627. //若相同连续的棋子计数达到五个，则更改flag的值
628. if(count >= 5){
629. flag = true;
630. }
631. return flag;
632. }
633. @Override
634. public void mouseReleased(MouseEvent e) {
635. }
636. @Override
637. public void mouseEntered(MouseEvent e) {
638. }
639. @Override
640. public void mouseExited(MouseEvent e) {
641. }
642. @Override
643. //倒计时设置
644. public void run() {
645. //当设置时间大于0时，程序才会开始
646. if(maxTime>0){
647. //设置程序一直运行
648. while(true){
649. //设置黑方时间减少
650. if(Black){
651. //当黑方时间大于0时，设置黑方时间每秒减一
652. if(BTime > 0){
653. BTime--;
654. }
655. //黑方游戏时间耗尽时，判断游戏结束
656. if(BTime == 0){
657. JOptionPane.showMessageDialog(this,"黑方超时，游戏结束！");
658. Goon = false;
659. //当黑方时间等于0时，设置时间为-1，防止倒计时继续运转
660. BTime = -1;
661. }
662. }else{
663. if(WTime > 0){
664. //设置白方时间每秒减一
665. WTime--;
666. }
667. if(WTime == 0){
668. //白方游戏时间耗尽时，判断游戏结束
669. JOptionPane.showMessageDialog(this,"白方超时，游戏结束！");
670. Goon = false;
671. WTime = -1;
672. }
673. }
674. //设置黑方显示时间为时分秒的显示形式
675. bTime = BTime/3600+":"+
676. (BTime/60-BTime/3600*60)+":"+
677. (BTime-BTime/60*60);
678. //设置白方显示时间为时分秒的显示形式
679. wTime = WTime/3600+":"+
680. (WTime/60-WTime/3600*60)+":"+
681. (WTime-WTime/60*60);
682. //重绘棋盘，刷新时间
683. this.repaint();
684. try {
685. //设置停顿
686. Thread.sleep(1000);
687. } catch (InterruptedException e) {
688. e.printStackTrace();
689. }
690. //System.out.println(BTime+"---"+WTime);//测试内容
691. }
692. }
693. }
694. }

ResultManager.class

1. package FiveChessGame;
2. import java.io.*;
3. import java.nio.charset.StandardCharsets;
4. import java.time.LocalDateTime;
5. import java.time.format.DateTimeFormatter;
6. import java.util.ArrayList;
7. public class ResultManager {
8. private String filePath ="result.txt";
9. public void writeResult(String resultStr) throws IOException {
10. OutputStream outputStream = new FileOutputStream(filePath,true);
11. StringBuilder stringBuilder = new StringBuilder();
12. LocalDateTime localDateTime = LocalDateTime.now();
13. DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
14. //格式化
15. String dateTime = formatter.format(localDateTime);
16. // System.out.println(dateTime);
17. stringBuilder.append(dateTime).append(" | " + resultStr).append("\n");
18. String data = stringBuilder.toString();
19. byte[] bytes = data.getBytes(StandardCharsets.UTF_8);
20. try {
21. outputStream.write(bytes);
22. } catch (IOException e) {
23. e.printStackTrace();
24. } finally {
25. outputStream.close();
26. }
27. }
28. public ArrayList readResult() throws IOException {
29. // InputStream inputStream = new FileInputStream("result.txt");
30. InputStream inputStream = new FileInputStream(filePath);
31. byte[] buf = new byte[1024];
32. int byteRead = -1;
33. ArrayList resultList = new ArrayList();
34. while ((byteRead = inputStream.read(buf)) != -1) {
35. String data = new String(buf, 0, byteRead, StandardCharsets.UTF_8);
36. resultList.add(data);
37. // System.out.println(data);
38. }
39. return resultList;
40. }
41. // @Test
42. // public void testWriteResult() throws IOException {
43. // writeResult("黑方认输，白方获胜");
44. // ArrayList data = readResult();
45. // String res = "";
46. // for(Object obj : data){
47. // res += obj.toString();
48. System.out.println(obj);
49. // }
50. // System.out.println(res);
51. // }
52. }
53. 系统测试
    测试目的：减少使用bug，令五子棋程序流畅运行
    测试范围：边界问题，图片加载问题，倒计时问题，连子问题等
    测试工具：idea
    典型错误：1、当落子在棋盘边界时，编译器会不断报错
    原因：定义棋盘的数组发生越界行为
    2、程序刚运行时，图片会加载不出来
    原因：内容混乱，
    3、倒计时在为0后仍会往后倒数
    原因：run函数if语句判断有纰漏
    4、大于五个棋子相连时出现错误
    原因：judge判定未设想到该种情况
    测试手段：启动程序，任意进行一盘游戏，寻找可能的错误
    5.游戏功能测试
    游戏说明界面：

关于界面：
倒计时界面：

正确运行：

游戏输赢判断：

认输：

历史对局：

1. 本程序高内聚低耦合的特点，易扩展、易维护
2. 总结与体会
   此次Java大作业我的收获颇深。一开始只是我想着做一个简单的欢乐五子棋小游戏，结果如何实现五子相连困扰了我很久。一开始我的构想是遍历一遍棋盘，查看是否有五个棋子连在一起，但是这个方法后面证明既麻烦，又低效。一遍遍的查找资料后，发现可以以当前落子的位置为参考点，来看周围是否有棋子与该落子的位置实现五子相连，这种方法不仅快速，而且占用内存小，同时又因为以每一次落子点为参考位置，不会出现漏洞。
   悔棋的功能我构思了很久，本想放弃，但最后还是决定加上去。一开始我毫无头绪，后面一遍又一遍翻看代码时，重新开始游戏算法中的重绘棋盘给了我启发，只需要利用之前定义的棋盘坐标，短短十几行代码便搞定了我苦思冥想半天的问题。
   然后是加上倒计时。多线程对于我来说是有点陌生的，当然，现在依旧称不上太熟悉，而且最困难的一点是，这部分的资料有些繁杂，不同的帖子用的方法和标准都不太一样，我一时间找不到突破口。当然，既然我的程序用上了倒计时，最后我还是把它解决了，但是过程有一些痛苦。首先是给黑白双方各设置一个线程，然后设置时间变量，当然，开始的时候因为变量设置太多把自己给绕进去了。然后是写run函数，设置停顿，一点一点试错，最后拼凑出来。剩下的部分就是倒计时的显示了，解决的方法让我有些出乎意料，只是简单的一个除法，加上计算机语言的特质就令我查阅许久。
   最后是历史对局功能，我本来想着使用文件读写在弹窗出输赢的之后写入白方赢了，或者黑方赢了到文件中，然后再用窗口把他调用出来，但是这样会出现问题，也不能很好实现历史对局，后面经过反复观看文件读写相关视频才来了灵感。
   上面三个功能，当我在查阅资料时，鲜有程序做到了这些，一开始我只是打算按教程去做项目，但后面随着一行行代码的敲下，我逐渐想要加上自己独属的内容。此次大作业，让我发现，其实一些看似不可思议的操作实际上只是基本方法的熟练使用，比如五子连珠的判断，其实就是利用数组的特点，倒计时显示更是只用了四则运算，没有太多花里胡哨的东西，掌握好基础知识才是最重要的。以及，变量的命名非常重要，好的命名方式可以节省不少时间，我再次在这次大作业中体会到了此点。
   追风赶月莫停留，平芜尽处是春山，以后我们想继续深入学习Java或者其他语言，我认为基础内容和一些代码规范是非常重要的，一味追求算法反而容易忽略最本质的东西。当然，定期练习项目，整合所学知识也非常重要。多看，多听，多练，在计算机领域尤其适用。
3. 自评分

自评分：93

自评语：本次大作业途中虽然遇到了很多困难，但我最终还是克服了这些困难，并在本次大作业中进行了创新，添加了倒计时，悔棋功能和查看历史对局功能，可以给游戏增加可玩性，不至于因为误触而影响游戏体验。