JAVA课程设计连连看(含代码)

Java程序课程设计任务书
1、主要内容：
本程序基本实现了小游戏连连看的功能，玩家找出游戏中2个相同图案的方块，如果它们之间的连接线不多于3根直线，则将其连接起来，就可以成功将图案相同的方块消除，否则不会消失，当游戏中已没有满足条件的图案时，点击重列，可重新排序，游戏结束会跳出所得分数，该游戏的特点是与自己竞争，超过自己之前所创纪录。

2、具体要求（包括技术要求等）：
a. 该游戏界面为方格类型，由纵6横7的直线平行垂直交叉组成，分别是
6行5列方块拼接，共有30格小方块。

方块上随机分布一些数字，数字的要求是至少两两相同，位置随机打乱。

b.当将相同数字的方块连接，但要满足只能至少单边无阻碍呈直线趋势连接，
否则无效，若连接一对成功就消失于界面，继续游戏，直到游戏结束，并能返回所得分数。

c. 重列按钮（帮助）的功能：游戏过程中，遇到困难难以寻找下一符合要求
的一对数字，可按左下按钮重置重新排列方可继续游戏。

d. 退出按钮：击左下方的“退出游戏”按钮，即可结束游戏。

e.运用基于SWING的图形用户界面设计知识等。

3、学习并掌握以下技术：Java等
4、熟练使用以下开发工具：Jcreate 等
实现系统上述的功能。

三、计划进度
12月28日-12月29 日：课程设计选题，查找参考资料
12月30日-12月31日：完成需求分析、程序设计
1月1日-1月3日：完成程序代码的编写
1月4日-1月6日：系统测试与完善
1月7日-1月8日：完成课程设计报告，准备答辩
四、主要参考文献
[1] （美）埃克尔著陈昊鹏，饶若楠等译. Java编程思想[J]. 机械工业出版社,2005
[2]（美）Gary J.Bronson著张珑刘雅文译. Java编程原理[J]. 清华大学出版社,2004
[3]（美）Michael Morrison著徐刚,于健,薛雷译. 游戏编程入门[J]. 人民邮电出版社,2005.9
[4]（美）Wendy Stahler著冯宝坤，曹英译. 游戏编程中的数理应用[J]. 红旗出版社,2005
[5]（美）克罗夫特(David Wallace Croft)著彭晖译. Java游戏高级编程[J]. 清华大学出版社,2005
[6]（美）David Brackeen著邱仲潘译. Java游戏编程[J]. 科学出版社,2004
[7] 聂庆亮编著. Java应用开发指南[J]. 清华大学出版社,2010
[8] 耿祥义，张跃平编著. Java面向对象程序设计[J]. 清华大学出版社,2010
[9] 杨绍方编著. Java编程实用技术与案例[J]. 清华大学出版社,2000.11
[10] 明日科技编著. Java编程全能词典[J]. 电子工业出版社,2010
摘要
随着Java语言的不断发展和壮大，现在的Java已经广泛的应用于各个领域，包括医药，汽车工业，手机行业，游戏，等等地方。

Java游戏的开发为满足人们娱乐所需而设计。

本游戏为连连看游戏，是基于Java的图形用户界面而开发的，可以放松心情的小游戏。

游戏从系统操作简便、界面友好、灵活、上手即会的基本要求出发，完成整款游戏的开发。

游戏更设置了重列、再来一局、退出等功能，简单易懂，为用户带来愉悦的体验。

本课程设计报告介绍了游戏的构想，分析，开发，实现的过程。

论述了游戏的功能开发，设计构思。

给出了游戏的设计步骤，游戏系统关键的设计思想；在游戏系统实现章节给出了部分功能流程和相关代码。

关键词：游戏，连连看
目录
JA V A程序课程设计任务书 (I)
摘要 ........................................................................................................................................................... I II 目录 (IV)
第一章引言 (1)
1.1背景 (1)
1.2课程设计内容 (1)
1.3任务分工 (1)
第二章连连看小游戏应用程序 (2)
2.1连连看小游戏应用程序概述 (2)
2.2连连看小游戏系统任务及目的 (2)
2.3本章小结 (2)
第三章连连看系统的设计 (3)
3.1算法设计 (3)
3.2系统开发及运行环境 (3)
3.3系统主要功能要求 (4)
3.4.1 连连看的总体结构 (4)
3.5连连看游戏系统流程图 (5)
3.6本章小结 (7)
第四章结束语 (8)
致谢 (9)
参考文献 (10)
附录源代码 (11)
第一章引言
1.1 背景
游戏是全球最大的娱乐经济项目之一，已经被命名为“第九艺术”。

而由“游戏”派生出来的职业，除了软件开发外，游戏包装宣传推广、攻略指导、网络游戏管理员和职业游戏玩家等，已成为了一系列专门的岗位。

面对游戏产业如此巨大的市场空间，国内各大城市纷纷加大了这方面的人才培养，中国的游戏人才培训已随着游戏行业的总体发展开始逐步迈入了正轨。

虽然说中国的游戏行业开始逐步的迈入了正轨，但是现今，游戏人才出现严重的瓶颈时期，高校的扩招、金融危机的侵袭直接影响着我们最关心的就业问题，但是另一方面游戏人才的缺乏又直接制约着行业的发展，这就更加严格了对社会培训机构的稳定性和正规性的要求。

在我国，游戏人才培养体系还未健全，部分开设了相关专业的高校，游由于理论和实践的脱离无法完全满足网游公司对人才的需求。

所以，就中国目前的市场分析来看，加强游戏产业必须在多渠道人才培养体系上加快突破，尽快建立起多渠道人才培养体系，来满足社会对游戏人才的需求。

1.2 课程设计内容
本程序基本实现了小游戏连连看的功能，玩家找出游戏中2个相同图案的方块，如果它们之间的连接线不多于3根直线，则将其连接起来，就可以成功将图案相同的方块消除，否则不会消失，当游戏中已没有满足条件的图案时，点击重列，可重新排序，游戏结束会跳出所得分数，该游戏的特点是与自己竞争，超过自己之前所创纪录。

1.3 任务分工
第二章连连看小游戏应用程序
2.1 连连看小游戏应用程序概述
此程序设计是一个小游戏（连连看）的实现，主要运用了用户图形界面，程序接口和基本函数绘制来实现，事件监听（包括鼠标事件，键盘事件，响应时间）也是这个程序的特色。

加入复选框，按钮，标签等来实现本游戏用户界面布局。

本游戏在用户界面的可操作性、游戏的美观度、计分结果方便都基本完善，有一定的可玩性。

2.2连连看小游戏系统任务及目的
此小程序是为群众闲暇消遣之用，进入游戏界面，即可开始游戏，接着是“重列”、“退出”、“再来一局”方便对游戏的控制。

2.3 本章小结
虽然游戏在功能和界面上不能算的上很棒，但是麻雀虽小，五脏俱全，游戏具备了弹砖块这个经典游戏锁应该具有的基本雏形。

通过这一章，我们对这个游戏应该有了比较宏观的了解，我们将在这一基础上探究游戏更完美的改变。

第三章连连看系统的设计
这一章时连连看系统的设计，从系统需求分析开始，介绍开发环境和用到的开发工具，系统主要的功能设计，系统的数据流程图。

3.1 算法设计
在检验两个方块能否消掉的时候，我们要让两个方块同时满足两个条件才行，就是两者配对并且连线成功。

分三种情况：（从下面的这三种情况，我们可以知道，需要三个检测，这三个检测分别检测一条直路径。

这样就会有三条路径。

若这三条路径上都是空按钮，那么就刚好是三种直线（两个转弯点）把两个按钮连接起来了）
1相邻
2若不相邻的先在第一个按钮的同行找一个空按钮找到后看第二个按钮横向到这个空按钮所在的列是否有按钮，没有的话再看第一个按钮到它同行的那个空按钮之间是否有按钮，没有的话再从与第一个按钮同行的那个空按钮竖向到与第二个按钮的同行看是否有按钮，没有的话路径就通了，可以消了。

3若2失败后，再在第一个按钮的同列找一个空按钮，找到后看第二个按钮竖向到这个空按钮所在的行是否有按钮，没有的话再看第一个按钮到与它同列的那个空按钮之间是否有按钮，没有的话路径就通了，可以消了。

若以上三步都失败，说明这两个按钮不可以消去。

3.2 系统开发及运行环境
硬件平台：
❑CPU：INTEL-I5。

❑内存：1024MB以上。

软件平台：
❑操作系统：Windows XP。

❑数据库：TXT文档。

❑开发工具包：JDK Version1.6.2。

❑分辨率：最佳效果1024×768像素
3.3 系统主要功能要求
本系统为了实现游戏连连看。

本系统主要实现如下功能：
❑系统界面美观大方舒适。

❑实现游戏一些基础信息的保存和读取。

❑画面流畅，具有可玩性
❑没有较大的游戏BUG。

❑显示游戏者的积分。

❑实现多种数字的排列模型。

❑系统最大限度地实现了易维护性和易操作性。

❑系统运行稳定、安全可靠。

3.4.1 连连看的总体结构
连连看游戏是基于基本的软件和普通硬件基础上的传统优秀游戏，一个游戏应该包括以下几大功能，如图3.1所示
图3.1 系统功能结构图3.5连连看游戏系统流程图
程序的流程图如下：
3.6 本章小结
本章是连连看游戏系统的具体设计过程，有具体的需求分析、系统功能模块、系统流程图。

这里我们开始接触连连看游戏系统开发的最初步骤，也是很重要的一步。

第四章结束语
由于市场需要，游戏的更新速度步步加快，为了适应社会的需要，社会对游戏开发人员的需求，在游戏编程的学习过程中，必须理论与实践结合，提高编程能力与水平。

通过小游戏的设计，对以学过的内容加深理解，对游戏开发的过程有初步的认识，为以后的游戏开发设计和更加深入的学习计算机语言打下夯实的基础。

目前竞争日益激烈的行业环境，对于未来行业的前景，还是要保持乐观的心态。

毕竟游戏并不是一下子就可以编写成的。

需要不断的技术积累，需要团队的合作，提高了工作的效率，才算是在游戏开发的道路上成功了一半。

在现在这个信息化飞速发展的道路上，要成为一名合格的编程人员，那就必须走好每一步现在的路。

基于Java的连连看小游戏，满足了用户娱乐的需求，已经达到了预期的目标。

虽然该游戏大部分功能基本上已经实现，但是还是会存在一些不足。

在今后的进步中，会逐步改进。

致谢
参考文献
[1] （美）埃克尔著陈昊鹏，饶若楠等译. Java编程思想[J]. 机械工业出版社,2005
[2]（美）Gary J.Bronson著张珑刘雅文译. Java编程原理[J]. 清华大学出版社,2004
[3]（美）Michael Morrison著徐刚,于健,薛雷译. 游戏编程入门[J]. 人民邮电出版社,2005.9
[4]（美）Wendy Stahler著冯宝坤，曹英译. 游戏编程中的数理应用[J]. 红旗出版社,2005
[5]（美）克罗夫特(David Wallace Croft)著彭晖译. Java游戏高级编程[J]. 清华大学出版社,2005
[6]（美）David Brackeen著邱仲潘译. Java游戏编程[J]. 科学出版社,2004
[7] 聂庆亮编著. Java应用开发指南[J]. 清华大学出版社,2010
[8] 耿祥义，张跃平编著. Java面向对象程序设计[J]. 清华大学出版社,2010
[9] 杨绍方编著. Java编程实用技术与案例[J]. 清华大学出版社,2000.11
[10] 明日科技编著. Java编程全能词典[J]. 电子工业出版社,2010
附录源代码
package mybase.programe;
/*
* lianliankan总体算法思路：由两个确定的按钮。

若这两个按钮的数字相等，就开始找它们相连的路经。

这个找路经
* 分3种情况：(从下面的这三种情况，我们可以知道，需要三个检测，这三个检测分别检测一条直路经。

这样就会有
* 三条路经。

若这三条路经上都是空按钮，那么就刚好是三种直线（两个转弯点）把两个按钮连接起来了)
* 1.相邻
*
* 2. 若不相邻的先在第一个按钮的同行找一个空按钮。

1).找到后看第二个按钮横向到这个空按钮
* 所在的列是否有按钮。

2).没有的话再看第一个按钮到与它同行的那个空按钮之间是否有按钮。

3).没有的话，再从
* 与第一个按钮同行的那个空按钮竖向到与第二个按钮的同行看是否有按钮。

没有的话路经就通了,可以消了.
*
* 3.若2失败后，再在第一个按钮的同列找一个空按钮。

1).找到后看第二个按钮竖向到这个空按钮所在的行是否有按钮。

* 2).没有的话，再看第一个按钮到与它同列的那个空按钮之间是否有按钮。

3).没有的话，再从与第一个按钮同列的
* 那个空按钮横向到与第二个按钮同列看是否有按钮。

没有的话路经就通了，可以消了。

*
* 若以上三步都失败，说明这两个按钮不可以消去。

*/
import javax.swing.*;
import java.awt.*;
import java.awt.event.*;
public class LianLianKan implements ActionListener {
JFrame mainFrame; // 主面板
Container thisContainer;
JPanel centerPanel, southPanel, northPanel; // 子面板
JButton diamondsButton[][] = new JButton[6][5];// 游戏按钮数组
JButton exitButton, resetButton, newlyButton; // 退出，重列，重新开始按钮JLabel fractionLable = new JLabel("0"); // 分数标签
JButton firstButton, secondButton; // 分别记录两次被选中的按钮
// 储存游戏按钮位置(这里其实只要6行，5列。

但是我们用了8行，7列。

是等于在这个面板按钮的周围还围
//了一层是0的按钮,这样就可以实现靠近面板边缘的两个按钮可以消去)
int grid[][] = new int[8][7];
static boolean pressInformation = false; // 判断是否有按钮被选中
int x0 = 0, y0 = 0, x = 0, y = 0, fristMsg = 0, secondMsg = 0, validateLV; // 游戏按钮的位置坐标
int i, j, k, n;// 消除方法控制
public void init() {
mainFrame = new JFrame("JKJ连连看");
thisContainer = mainFrame.getContentPane();
thisContainer.setLayout(new BorderLayout());
centerPanel = new JPanel();
southPanel = new JPanel();
northPanel = new JPanel();
thisContainer.add(centerPanel, "Center");
thisContainer.add(southPanel, "South");
thisContainer.add(northPanel, "North");
centerPanel.setLayout(new GridLayout(6, 5));
for (int cols = 0; cols < 6; cols++) {
for (int rows = 0; rows < 5; rows++) {
diamondsButton[cols][rows] = new JButton(String
.valueOf(grid[cols + 1][rows + 1]));
diamondsButton[cols][rows].addActionListener(this);
centerPanel.add(diamondsButton[cols][rows]);
}
}
exitButton = new JButton("退出");
exitButton.addActionListener(this);
resetButton = new JButton("重列");
resetButton.addActionListener(this);
newlyButton = new JButton("再来一局");
newlyButton.addActionListener(this);
southPanel.add(exitButton);
southPanel.add(resetButton);
southPanel.add(newlyButton);
fractionLable.setText(String.valueOf(Integer.parseInt(fractionLable
.getText())));
northPanel.add(fractionLable);
mainFrame.setBounds(280, 100, 500, 450);
mainFrame.setVisible(true);
mainFrame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); }
public void randomBuild() {
int randoms, cols, rows;
for (int twins = 1; twins <= 15; twins++) {//一共15对button,30个randoms = (int) (Math.random() * 25 + 1);//button上的数字
for (int alike = 1; alike <= 2; alike++) {
cols = (int) (Math.random() * 6 + 1);
rows = (int) (Math.random() * 5 + 1);
while (grid[cols][rows] != 0) {//等于0说明这个空格有了button cols = (int) (Math.random() * 6 + 1);
rows = (int) (Math.random() * 5 + 1);
}
this.grid[cols][rows] = randoms;
}
}
}
public void fraction() {
fractionLable.setText(String.valueOf(Integer.parseInt(fractionLable .getText()) + 100));
}
public void reload() {
int save[] = new int[30];
int n = 0, cols, rows;
int grid[][] = new int[8][7];
for (int i = 0; i <= 6; i++) {
for (int j = 0; j <= 5; j++) {
if (this.grid[i][j] != 0) {
save[n] = this.grid[i][j];//记下每个button的数字
n++;//有几个没有消去的button
}
}
}
n = n - 1;
this.grid = grid;
while (n >= 0) {//把没有消去的button重新放一次
cols = (int) (Math.random() * 6 + 1);
rows = (int) (Math.random() * 5 + 1);
while (grid[cols][rows] != 0) {
cols = (int) (Math.random() * 6 + 1);
rows = (int) (Math.random() * 5 + 1);
}
this.grid[cols][rows] = save[n];
n--;
}
mainFrame.setVisible(false);
pressInformation = false; // 这里一定要将按钮点击信息归为初始
init();
for (int i = 0; i < 6; i++) {
for (int j = 0; j < 5; j++) {
if (grid[i + 1][j + 1] == 0)
diamondsButton[i][j].setVisible(false);
}
}
}
public void estimateEven(int placeX, int placeY, JButton bz) {
if (pressInformation == false) {
x = placeX;
y = placeY;
secondMsg = grid[x][y];
secondButton = bz;
pressInformation = true;
} else {
x0 = x;
y0 = y;
fristMsg = secondMsg;
firstButton = secondButton;
x = placeX;
y = placeY;
secondMsg = grid[x][y];
secondButton = bz;
if (fristMsg == secondMsg && secondButton != firstButton) {
xiao();
}
}
}
public void xiao() { // 相同的情况下能不能消去。

仔细分析，不一条条注释if ((x0 == x && (y0 == y + 1 || y0 == y - 1))
|| ((x0 == x + 1 || x0 == x - 1) && (y0 == y))) { // 判断是否相邻
remove();
} else {
for (j = 0; j < 7; j++) {
if (grid[x0][j] == 0) { // 判断和第一个按钮同行的哪个按钮为空
//如果找到一个为空的，就按列值的三种情况比较第二个按钮与空按钮的位置
if (y > j) {//第二个按钮在空按钮右边
for (i = y - 1; i >= j; i--) { //检测从第二个按钮横向左边到空格所在列为止是否全是空格
if (grid[x][i] != 0) {
k = 0;
break;//存在非空格的就退出，这一退出就不可能k==2了，所以就会到下而215行出同理的判断列
} else {
k = 1;
} // K=1说明全是空格通过了第一次验证，也就是从第二个按钮横向左边到空格所在列为止全是空格
}
if (k == 1) {
linePassOne();//进入第二次验证，也就是从第一个按钮到它同行的空格之间的空格判断
}
}
if (y < j) { // 第二个按钮在空按钮左边
for (i = y + 1; i <= j; i++) {//检测从第二个按钮横向右边到空格所在列为止是否全是空格
if (grid[x][i] != 0) {
k = 0;
break;
} else {
k = 1;
}
}
if (k == 1) {
linePassOne();
}
}
if (y == j) {//第二个按钮和空按钮同列
linePassOne();
}
}
//第三次检测，检测确定为空的第j列的那个按钮竖向到第二个按钮，看是不
是有按钮
if (k == 2) {
if (x0 == x) {//第一，二按钮在同行
remove();
}
if (x0 < x) {//第一按钮在第二按钮下边
for (n = x0; n <= x - 1; n++) {//从空按钮竖向到第二个按钮所在行是否有按钮
if (grid[n][j] != 0) {
k = 0;
break;
}
//没有按钮，说明这条路经就通了
if (grid[n][j] == 0 && n == x - 1) {
remove();
}
}
}
if (x0 > x) {//第一按钮在第二按钮上边
for (n = x0; n >= x + 1; n--) {
if (grid[n][j] != 0) {
k = 0;
break;
}
if (grid[n][j] == 0 && n == x + 1) {
remove();
}
}
}
}
}//-------------------------------------for
//当上面的检测与第一个按钮同行的空格按钮失败后(不能找到与第二个按钮的相连路经)，下面就执行
//检测与第一个按钮同列的空格按钮
for (i = 0; i < 8; i++) {
if (grid[i][y0] == 0) {// 判断和第一个按钮同列的哪个按钮为空
if (x > i) {//第二个按钮在这个空按钮的下面
for (j = x - 1; j >= i; j--) {
if (grid[j][y] != 0) {
k = 0;
break;
} else {
k = 1;
}
}
if (k == 1) {
rowPassOne();
}
}
if (x < i) {//第二个按钮在这个空按钮的上面for (j = x + 1; j <= i; j++) {
if (grid[j][y] != 0) {
k = 0;
break;
} else {
k = 1;
}
}
if (k == 1) {
rowPassOne();
}
}
if (x == i) {//第二个按钮与这个空按钮同行rowPassOne();
}
}
if (k == 2) {
if (y0 == y) {//第二个按钮与第一个按钮同列remove();
}
if (y0 < y) {//第二个按钮在第一个按钮右边for (n = y0; n <= y - 1; n++) {
if (grid[i][n] != 0) {
k = 0;
break;
}
if (grid[i][n] == 0 && n == y - 1) {
remove();
}
}
}
if (y0 > y) {//第二个按钮在第一个按钮左边
for (n = y0; n >= y + 1; n--) {
if (grid[i][n] != 0) {
k = 0;
break;
}
if (grid[i][n] == 0 && n == y + 1) {
remove();
}
}
}
}
}//--------------------------------for
}//-------------else
}//------------xiao
public void linePassOne() {
if (y0 > j) { // 第一按钮同行空按钮在左边
for (i = y0 - 1; i >= j; i--) { // 判断第一按钮同左侧空按钮之间有没按钮if (grid[x0][i] != 0) {
k = 0;
break;
} else {
k = 2;
} // K=2说明通过了第二次验证
}
}
if (y0 < j) { // 第一按钮同行空按钮在右边
for (i = y0 + 1; i <= j; i++) {
if (grid[x0][i] != 0) {
k = 0;
break;
} else {
k = 2;
}
}
}
}
public void rowPassOne() {
if (x0 > i) {//第一个按钮在与它同列的那个空格按钮下面
for (j = x0 - 1; j >= i; j--) {
if (grid[j][y0] != 0) {
k = 0;
break;
} else {
k = 2;
}
}
}
if (x0 < i) {//第一个按钮在与它同列的那个空格按钮上面for (j = x0 + 1; j <= i; j++) {
if (grid[j][y0] != 0) {
k = 0;
break;
} else {
k = 2;
}
}
}
}
public void remove() {
firstButton.setVisible(false);
secondButton.setVisible(false);
fraction();
pressInformation = false;
k = 0;
grid[x0][y0] = 0;
grid[x][y] = 0;
}
public void actionPerformed(ActionEvent e) {
if (e.getSource() == newlyButton) {
int grid[][] = new int[8][7];
this.grid = grid;
randomBuild();
mainFrame.setVisible(false);
pressInformation = false;
init();
}
if (e.getSource() == exitButton)
System.exit(0);
if (e.getSource() == resetButton)
reload();
for (int cols = 0; cols < 6; cols++) {
for (int rows = 0; rows < 5; rows++) {
if (e.getSource() == diamondsButton[cols][rows])
estimateEven(cols + 1, rows + 1, diamondsButton[cols][rows]);
}
}
}
public static void main(String[] args) {
LianLianKan llk = new LianLianKan();
llk.randomBuild();
llk.init();
}
}。