(完整版)Java毕业课程设计连连看游戏(含代码)
连连看-JAVA课程设计报告
课程设计2013 ~ 2014学年第二学期设计题目连连看游戏程序院（系）专业软件工程班级学号学生姓名设计时间 2014年6月24日~2014年6月27日指导教师提交日期 2014年6月27日目录目录 (2)1.课程设计的目的与要求 (3)1.1课程设计目的与要求 (3)1.2课程设计内容 (3)1.3课程设计的实验环境 (3)1.4课程设计的预备知识 (3)2.系统模块结构图 (4)2.1 模块设计 (4)2.1.1 菜单控制模块 (4)2.1.2 算法模块 (5)2.1.3 界面显示模块 (7)3.详细设计 (9)3.1总体算法思路 (9)3.2代码实现 (9)4.小结 (9)1.课程设计的目的与要求1.1课程设计目的与要求1.掌握JA V A语言中面向对象的概念，并能在程序中熟练运用。
2.了解面向对象程序设计（JA V A）的基本概念以及运用面向对象技术进行程序设计的基本思想。
3.能正确编写和调试JA V A程序。
4.了解在JA V A环境下进行程序设计的基本思想和方法。
1.2课程设计内容1.设计一个连连看的游戏程序。
2.在JA V A环境下，将上述程序使用GUI、数据结构等内容完成3.设计思路：(1)界面设计1)初始测试界面可以考虑使用简单的按钮来代表连连看游戏中的图标。
2)布局可以考虑使用GRID方式。
3)设计菜单选择连连看难度等内容，具体可参照QQ连连看，也可自定义。
4)考虑完善界面，例如动画等。
(2)代码设计1)本设计的核心为练练看算法的设计，可以考虑数据结构中的图的遍历章节，合理设计算法，将界面中各按钮的分布映射入数学矩阵进行路径规划。
（可以上网搜索相关算法）。
2)完成连连看游戏的图形、算法等代码的设计。
4.实验步骤（包括操作方法、数据处理）(1)界面设计(2)算法设计(3)代码设计1.3课程设计的实验环境硬件要求能运行Windows xp/7操作系统的微机系统。
JAVA程序设计语言及相应的集成开发环境， ECLIPSE开发工具。
连连看游戏java课程设计
连连看游戏java课程设计一、课程目标知识目标：1. 理解Java语言中面向对象编程的基本概念，如类、对象、继承、封装等；2. 学会使用Java编写连连看游戏的界面布局和逻辑控制；3. 掌握运用Java集合框架处理游戏数据结构；4. 了解Java事件处理机制，并能应用于游戏交互。
技能目标：1. 能够运用面向对象的方法设计游戏类和对象，实现游戏功能；2. 独立编写连连看游戏的界面和逻辑代码，完成一个完整的Java游戏项目；3. 学会使用集合框架优化游戏数据存储和访问；4. 提高问题分析、程序设计和调试能力。
情感态度价值观目标：1. 培养学生对编程的兴趣，激发创造力和创新能力；2. 培养学生合作学习、分享交流的良好习惯，提高团队协作能力；3. 强化学生的逻辑思维能力，提高解决实际问题的能力；4. 培养学生面对挑战时的积极态度，勇于克服困难，持续优化和完善自己的作品。
课程性质：本课程为信息技术学科选修课程，以项目为导向，注重实践操作和团队合作。
学生特点：学生具备一定的Java编程基础，对游戏开发有浓厚兴趣，具有较强的动手能力和创新能力。
教学要求：结合实际项目需求，引导学生运用所学知识解决问题，注重培养学生的编程能力和团队协作能力，提高学生的综合素质。
通过本课程的学习，使学生能够独立完成一个连连看游戏的Java课程设计。
二、教学内容1. 面向对象编程基础复习：复习Java中类与对象、继承、封装等基本概念，参考教材第二章。
2. 游戏界面设计：学习使用Java的Swing库设计连连看游戏界面，包括菜单、按钮、网格布局等，结合教材第四章。
- 界面组件及布局管理器；- 事件监听器和处理机制；- 图形和图标的使用。
3. 游戏逻辑实现：学习实现游戏核心逻辑，如数据结构设计、游戏规则、配对消除等，参考教材第六章。
- 集合框架的使用；- 算法实现（如查找、排序）；- 游戏流程控制。
4. 游戏对象设计：设计游戏中的对象类，如卡片类、游戏引擎类等，运用封装、继承等面向对象原则，参考教材第三章。
java实战之连连看游戏源码(完整版)
import javax.swing.*;import java.awt.*;import java.awt.event.*;public class liankan implements ActionListener {JFrame mainFrame; //主面板JPanel centerPanel,saidPanel; //子面板JButton diamondsButton[][] = new JButton[10][10];//游戏按钮数组JButton firstButton, secondButton; //分别记录两次被选中的按钮JButton backButton,remarkButton,newlyButton,startButton;//返回，重列，重新,开始|暂停按钮JLabel lable1 = new JLabel("分数：");JLabel lable2 = new JLabel("0"); //分数标签int grid[][] = new int[12][12];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 AddGif(){for (int cols = 0; cols < 10; cols++){for (int rows = 0; rows < 10; rows++){diamondsButton[cols][rows]=new JButton(newImageIcon(String.valueOf(grid[cols + 1][rows + 1])+".gif"));diamondsButton[cols][rows].addActionListener(this);centerPanel.add(diamondsButton[cols][rows]);}}}public voidcreate(){mainFrame = new JFrame("连连看");mainFrame.setLayout(null);centerPanel = new JPanel();saidPanel = new JPanel();saidPanel.setLayout(null);saidPanel.setBackground(Color.yellow);centerPanel.setLayout(new GridLayout(10,10)); //10*10的网格布局AddGif();backButton = new JButton("返回");backButton.addActionListener(this);remarkButton = new JButton("重列");remarkButton.addActionListener(this);newlyButton = new JButton("重新开始");newlyButton.addActionListener(this);mainFrame.setBounds(100, 100, 750, 550);mainFrame.add(centerPanel);saidPanel.add(lable1);saidPanel.add(lable2);mainFrame.add(saidPanel);saidPanel.add(remarkButton);saidPanel.add(newlyButton);remarkButton.setBounds(100,100,90,30);newlyButton.setBounds(100,150,90,30);saidPanel.setBounds(470,0,270,530);lable1.setBounds(100,50,70,50);lable2.setBounds(170,50,100,50);centerPanel.setBounds(50,50,370,410);mainFrame.setVisible(true);mainFrame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);}public void randomBuild(){int randoms, cols, rows;for (int twins = 1; twins <= 25; twins++){//一共15对button,30个randoms = (int) (Math.random() * 25 + 1);//button上的数字for (int alike = 1; alike <= 4; alike++){cols = (int) (Math.random() * 10 + 1);rows = (int) (Math.random() * 10 + 1);while (grid[cols][rows] != 0) //等于0说明这个空格有了button {cols = (int) (Math.random() * 10 + 1);rows = (int) (Math.random() * 10 + 1);}this.grid[cols][rows] = randoms;}}}public void reload(){int save[] = new int[100];int n = 0, cols, rows;int grid[][] = new int[12][12];for (int i = 0; i <= 10; i++){for (int j = 0; j <= 10; 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() * 10 + 1);rows = (int) (Math.random() * 10 + 1);while (grid[cols][rows] != 0){cols = (int) (Math.random() * 10 + 1);rows = (int) (Math.random() * 10 + 1);}this.grid[cols][rows] = save[n];n--;}mainFrame.setVisible(false);pressInformation = false; //这里一定要将按钮点击信息归为初始create();for (int i = 0; i < 10; i++){for (int j = 0; j < 10; 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 fraction(){ //分数加100lable2.setText(String.valueOf(Integer.parseInt(lable2.getText()) + 100));}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 < 12; 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 < 12; 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}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[12][12];this.grid = grid;lable2.setText("0");randomBuild();mainFrame.setVisible(false);pressInformation = false;create();}if (e.getSource() == remarkButton)reload();for (int cols = 0; cols < 10; cols++){for (int rows = 0; rows < 10; rows++){if (e.getSource() == diamondsButton[cols][rows])estimateEven(cols + 1, rows + 1, diamondsButton[cols][rows]);}}}public static void main(String[] args){liankan llk = new liankan();llk.randomBuild();llk.create();}}。
JAVA连连看课程设计报告
滨江学院实验报告||实验名称JAVA小游戏（连连看）设计课程名称智能手机程序设计| |专业班级：信息工程1班学生姓名：车宇翔学号：20112309002指导教师：高超学期：2013-2014(2)成绩：【选题背景】：连连看游戏经验，玩法简单，休闲，益智，趣味，广受欢迎。
【选题目的】：学会JAVA程序开发的环境搭建与配置，并在实际运用中学习和掌握JAVA程序开发的全过程。
进一步熟悉掌握JAVA程序设计语音的基础内容，如用户图形界面设计、JAVA多线程编程、JAVA数据库编程等。
通过亲自动手写程序，拓展知识面，锻炼调试能力。
【系统分析与设计】：功能分析：实现连连看的基本游戏功能和重置、提示、消除功能设计：通过对图片的调用以及设置是否可见来完成连连看的效果【课程设计中碰到的问题及解决方案】：1.不知道如何进行对数组中两个元素是否可以消除的判断2.时间条的动态表现解决方案：1.对每个相同图案进行循环判断，直到找出满足条件的情况boolean verticalMatch(Point a, Point b) // 竖线上的判断boolean horizonMatch(Point a, Point b) // 横线上的判断2.为了保证动画过程和游戏过程的平行运行，因此将动画分离成一个独立的控件，并且要保证动画有自己单独的线程来运行。
当每次用户的分数发生变化时，我们可以使用setScore(int l, int c) 方法同步分数显示的动画效果。
【程序输出结果】：游戏开始【程序代码】：ImageFactorypackage nicholas.game.kyodai;import javax.swing.ImageIcon;import .*;public class ImageFactory {private static ImageFactory imagefactory;private static ImageIcon images[];private ImageFactory() {images = new ImageIcon[54];URLClassLoader loader = (URLClassLoader)getClass().getClassLoader();for(int i=0;i<39;i++) {images[i] = new ImageIcon(getClass().getResource("images/"+i+".gif"));}images[39] = new ImageIcon(getClass().getResource("images/dots.gif"));images[40] = new ImageIcon(getClass().getResource("images/ico.gif"));images[41] = new ImageIcon(getClass().getResource("images/topbar.gif"));images[42] = new ImageIcon(getClass().getResource("images/splash.gif"));images[43] = new ImageIcon(getClass().getResource("images/sico.gif"));}public ImageIcon getImageicon(int i) {return images[i];}public static synchronized ImageFactory getInstance() {if(imagefactory != null) {return imagefactory;} else {imagefactory = new ImageFactory();return imagefactory;}}}KyodaiGridpackage nicholas.game.kyodai;import java.awt.*;import javax.swing.*;public class KyodaiGrid extends JLabel {private int xpos;private int ypos;public KyodaiGrid(int x, int y) {xpos = x;ypos = y;this.setHorizontalAlignment(SwingConstants.CENTER);}public int getXpos() {return xpos;}public int getYpos() {return ypos;}public boolean isPassable() {return !isVisible();}}LevelInfopackage nicholas.game.kyodai;import java.io.Serializable;public class LevelInfo implements Serializable {//xBound为行号,yBound为列号private int xBound;private int yBound;public LevelInfo() {xBound = 16;yBound = 9;}public LevelInfo(int x, int y){xBound = x;yBound = y;}public int getXBound() {return xBound;}public int getYBound() {return yBound;}}MainFrame.javapackage nicholas.game.kyodai;import java.awt.*;import java.awt.event.*;import java.io.*;import javax.swing.*;import nicholas.swing.AboutDialog;import nicholas.swing.JSplashWindow;public class MainFrame extends JFrame implements ActionListener {private JMenuItem aboutItem;//菜单栏private JMenuItem exitItem;private JMenuItem startItem;private JMenuItem optionItem;private JMenuItem tipItem;private JMenuItem refreshItem;private JMenuItem logItem;private JMenuItem bombItem;private JMenuItem pauseItem;private MainPanel mainPanel;//完成主要功能private LevelInfo levelInfo;public MainFrame() {super("连连看");levelInfo = new LevelInfo();//设定游戏大小setMenuBar();//设置菜单setUI();setIconImage(ImageFactory.getInstance().getImageicon(43).getImage());setSize(650,520);Dimension screen = getToolkit().getScreenSize();setLocation((screen.width-getSize().width)/2,(screen.height-getSize().height)/2);this.setVisible(true);addWindowListener(new WindowAdapter() {public void windowClosing(WindowEvent e) {System.exit(0);}});}private void setMenuBar() {JMenu fileMenu = new JMenu("游戏(G)");JMenu helpMenu = new JMenu("帮助(H)");JMenu contMenu = new JMenu("辅助(C)");fileMenu.setMnemonic('G');helpMenu.setMnemonic('H');contMenu.setMnemonic('C');startItem = new JMenuItem("开局(N)");startItem.setMnemonic('N');startItem.setAccelerator(KeyStroke.getKeyStroke(KeyEvent.VK_F2,0));pauseItem = new JMenuItem("暂停(P)");pauseItem.setMnemonic('P');pauseItem.setAccelerator(KeyStroke.getKeyStroke(KeyEvent.VK_PAUSE,0));refreshItem = new JMenuItem("刷新(R)");refreshItem.setMnemonic('R');refreshItem.setAccelerator(KeyStroke.getKeyStroke(KeyEvent.VK_F3,0));tipItem = new JMenuItem("提示(T)");tipItem.setMnemonic('T');tipItem.setAccelerator(KeyStroke.getKeyStroke(KeyEvent.VK_F5,0));optionItem = new JMenuItem("选项(O)...");optionItem.setMnemonic('O');logItem = new JMenuItem("排行榜(B)...");logItem.setMnemonic('B');exitItem = new JMenuItem("退出(X)");exitItem.setMnemonic('X');aboutItem = new JMenuItem("关于(A)...");aboutItem.setMnemonic('A');aboutItem.setAccelerator(KeyStroke.getKeyStroke(KeyEvent.VK_F1,0));bombItem = new JMenuItem("炸弹(M)");bombItem.setAccelerator(KeyStroke.getKeyStroke(KeyEvent.VK_F4,0));bombItem.setMnemonic('M');startItem.addActionListener(this);pauseItem.addActionListener(this);refreshItem.addActionListener(this);tipItem.addActionListener(this);optionItem.addActionListener(this);logItem.addActionListener(this);exitItem.addActionListener(this);aboutItem.addActionListener(this);bombItem.addActionListener(this);fileMenu.add(startItem);fileMenu.add(pauseItem);contMenu.add(refreshItem);contMenu.add(bombItem);contMenu.add(tipItem);fileMenu.addSeparator();fileMenu.add(exitItem);helpMenu.add(aboutItem);helpMenu.add(contMenu);JMenuBar bar = new JMenuBar();bar.add(fileMenu);bar.add(helpMenu);setJMenuBar(bar);}private void setUI() {mainPanel = new MainPanel(levelInfo);getContentPane().add(mainPanel,BorderLayout.CENTER); }public static void main(String args[]) {MainFrame application = new MainFrame();}private void showAboutDialog() {String s1="作者：车宇翔";String s2="邮箱： 531608022@";String s3="Have Fun!!";TextArea ta=new TextArea();ta.setText(s1+"\n"+"\n"+"\n"+s2+"\n"+"\n"+"\n"+s3);ta.setEditable(false);JFrame f=new JFrame("关于");f.setLocation(300, 300);f.setSize(200,200);f.add(ta);f.setBackground(new Color(200,120,150));f.setResizable(false);f.setVisible(true);}public void actionPerformed(ActionEvent ae) { if(ae.getSource()==startItem) {mainPanel.restart();} else if(ae.getSource()==pauseItem) {mainPanel.setPaused(!mainPanel.isPaused());} else if(ae.getSource()==exitItem) {System.exit(0);} else if(ae.getSource()==aboutItem) {showAboutDialog();} else if(ae.getSource()==bombItem) {eBomb();} else if(ae.getSource()==refreshItem) {mainPanel.refresh();} else if(ae.getSource()==tipItem) {mainPanel.showNext();}}}MainPanel.javapackage nicholas.game.kyodai;import java.awt.*;import java.awt.event.*;import java.util.Vector;import javax.swing.*;import javax.swing.border.Border;import nicholas.game.kyodai.*;public class MainPanel extends JPanel {private int BOMB = 5;private int BOMBP = 200;private int REFRESH = 4;private int REFRP = 250;private int TIP = 7;private int TIPP = 120;private int PROGRESS = 1200;private int xBound;private int yBound;private int pcount;private int score;private int refreshcount;private int bombcount;private int tipcount;private LevelInfo levelInfo; private GridMouseAdapter gma; private KyodaiGrid grid[][]; private KyodaiGrid nexts, nexte;private Border selectedBorder; private Border opaqueBorder; private Border tipBorder;private Vector path[];private Thread pthread;private JProgressBar progress; private JLabel scoreLabel; private JLabel refreshLabel; private JLabel bombLabel;private JLabel tipLabel;private JPanel gridPanel;private boolean wingame;public MainPanel(LevelInfo li) {super(new BorderLayout());levelInfo = li;path = new Vector[3];path[0] = new Vector();path[1] = new Vector();path[2] = new Vector();setBackground(Color.black);gma = new GridMouseAdapter();opaqueBorder = BorderFactory.createLineBorder(getBackground());//selectedBorder = BorderFactory.createLineBorder(Color.red);selectedBorder = BorderFactory.createLineBorder(Color.red);tipBorder = BorderFactory.createLineBorder(Color.green);setGridPanel();setStatusPanel();}/***设置状态面板*/private void setStatusPanel() {wingame = false;JPanel panel = new JPanel();panel.setBackground(Color.black);JLabel label = new JLabel("剩余时间:");label.setForeground(Color.white);panel.add(label);progress = new JProgressBar(0,PROGRESS);//时间条显示progress.setValue(PROGRESS);progress.setPreferredSize(new Dimension(400,20));progress.setForeground(Color.blue);progress.setBorderPainted(false);panel.add(progress);score = 0;scoreLabel = new JLabel(""+score);scoreLabel.setForeground(Color.yellow);scoreLabel.setFont(new Font("Dialog",Font.BOLD,25));scoreLabel.setHorizontalAlignment(SwingConstants.RIGHT);scoreLabel.setPreferredSize(new Dimension(100,20));panel.add(scoreLabel);add(panel,BorderLayout.NORTH);panel = new JPanel();panel.setBackground(Color.black);label = new JLabel("剩余提示：");label.setForeground(Color.yellow);panel.add(label);tipcount = TIP;tipLabel = new JLabel(""+tipcount);tipLabel.setForeground(Color.green);panel.add(tipLabel);label = new JLabel("剩余炸弹：");label.setForeground(Color.yellow);panel.add(label);bombcount = BOMB;bombLabel = new JLabel(""+bombcount);bombLabel.setForeground(Color.green);panel.add(bombLabel);label = new JLabel("可用刷新：");label.setForeground(Color.yellow);panel.add(label);refreshcount = REFRESH;refreshLabel = new JLabel(""+refreshcount);refreshLabel.setForeground(Color.green);panel.add(refreshLabel);add(panel,BorderLayout.SOUTH);pthread = new ProgressThread();pthread.start();}private void setGridPanel() {//完成布局gridPanel = new JPanel();gridPanel.setBackground(getBackground());xBound = levelInfo.getXBound()+2;yBound = levelInfo.getYBound()+2;gridPanel.setLayout(new GridLayout(yBound,xBound,0,0));grid = new KyodaiGrid[yBound][xBound];int count = 0;int sub = levelInfo.getXBound()*levelInfo.getYBound()/4;KyodaiGrid temp[] = new KyodaiGrid[xBound*yBound];for(int y=0;y<yBound;y++) {for(int x=0;x<xBound;x++) {grid[y][x] = new KyodaiGrid(x, y);if(x==0||x==(xBound-1)||y==0||y==(yBound-1)) {grid[y][x].setIcon(ImageFactory.getInstance().getImageicon(39));grid[y][x].setVisible(false);} else {grid[y][x].setIcon(ImageFactory.getInstance().getImageicon(count%sub));grid[y][x].setBorder(opaqueBorder);grid[y][x].addMouseListener(gma);temp[count] = grid[y][x];count++;}gridPanel.add(grid[y][x]);}}JPanel t = new JPanel();t.setBackground(Color.black);t.add(gridPanel);add(t,BorderLayout.CENTER);shuffle(temp, count);}/***开始新游戏*/public void restart() {//重新开始resetStatusPanel();resetGridPanel();}/***重置面板状态和游戏图标*/private void resetStatusPanel() {wingame = false;score = 0;scoreLabel.setText(""+score);bombcount = BOMB;bombLabel.setText(""+bombcount);refreshcount = REFRESH;refreshLabel.setText(""+refreshcount);tipcount = TIP;tipLabel.setText(""+tipcount);progress.setValue(PROGRESS);pthread.resume();}private void resetGridPanel() {int count = 0;int sub = (xBound-2)*(yBound-2)/4;KyodaiGrid temp[] = new KyodaiGrid[xBound*yBound];for(int y=1;y<yBound-1;y++) {for(int x=1;x<xBound-1;x++){grid[y][x].setIcon(ImageFactory.getInstance().getImageicon(count%sub));grid[y][x].setBorder(opaqueBorder);grid[y][x].setVisible(true);temp[count] =grid[y][x];count++;}}shuffle(temp,count);}/***暂停*/public void setPaused(boolean p) {if(p) {pthread.suspend();gridPanel.setVisible(false);} else {pthread.resume();gridPanel.setVisible(true);}}/***是否暂停*/public boolean isPaused() {return !gridPanel.isVisible();}/***没有布局存在时胜利*计算得分*/private void win() {wingame = true;pthread.suspend();score += progress.getValue()/20+bombcount*BOMBP+refreshcount*REFRP+tipcount*TIPP;scoreLabel.setText(""+score);}private void shuffle(KyodaiGrid array[], int count) {if(wingame) return;do {setVisible(false);int j,k;Icon temp;for(int i=0;i<count;i++) {j = (int)(Math.random()*count);k = (int)(Math.random()*count);temp = array[k].getIcon();array[k].setIcon(array[j].getIcon());array[j].setIcon(temp);}setVisible(true);} while(!findPair());}public void refresh() {if(wingame||progress.getValue()==0||refreshcount==0) return;KyodaiGrid temp[] = new KyodaiGrid[xBound*yBound];int count = 0;for(int y=1;y<yBound-1;y++) {for(int x=1;x<xBound-1;x++) {if(grid[y][x].isVisible()) {grid[y][x].setBorder(opaqueBorder);temp[count] = grid[y][x];count++;}}}if(count!=0) {refreshcount--;refreshLabel.setText(""+refreshcount);shuffle(temp,count);} else win();}private boolean xdirect(KyodaiGrid start, KyodaiGrid end,Vector path) { if(start.getYpos()!=end.getYpos()) return false;int direct = 1;if(start.getXpos()>end.getXpos()) {direct = -1;}path.removeAllElements();for(intx=start.getXpos()+direct;x!=end.getXpos()&&x<xBound&&x>=0;x+=direct) { if(grid[start.getYpos()][x].isVisible()) return false;path.add(grid[start.getYpos()][x]);}path.add(end);return true;}private boolean ydirect(KyodaiGrid start, KyodaiGrid end,Vector path) { if(start.getXpos()!=end.getXpos()) return false;int direct = 1;if(start.getYpos()>end.getYpos()) {direct = -1;}path.removeAllElements();for(inty=start.getYpos()+direct;y!=end.getYpos()&&y<yBound&&y>=0;y+=direct) { if(grid[y][start.getXpos()].isVisible()) return false;path.add(grid[y][start.getXpos()]);}path.add(end);return true;}private int findPath(KyodaiGrid start, KyodaiGrid end) {//0 connerif(xdirect(start,end,path[0])) {return 1;}if(ydirect(start,end,path[0])) {return 1;}//1 connerKyodaiGrid xy = grid[start.getYpos()][end.getXpos()];if(!xy.isVisible()&&xdirect(start,xy,path[0])&&ydirect(xy,end,path[1])) {return 2;}KyodaiGrid yx = grid[end.getYpos()][start.getXpos()];if(!yx.isVisible()&&ydirect(start,yx,path[0])&&xdirect(yx,end,path[1])) {return 2;}//2 conner//uppath[0].removeAllElements();for(int y=start.getYpos()-1;y>=0;y--) {xy = grid[y][start.getXpos()];yx = grid[y][end.getXpos()];if(xy.isVisible()) break;path[0].add(xy);if(!yx.isVisible()&&xdirect(xy,yx,path[1])&&ydirect(yx,end,path[2])) {return 3;}}//downpath[0].removeAllElements();for(int y=start.getYpos()+1;y<yBound;y++) {xy = grid[y][start.getXpos()];yx = grid[y][end.getXpos()];if(xy.isVisible()) break;path[0].add(xy);if(!yx.isVisible()&&xdirect(xy,yx,path[1])&&ydirect(yx,end,path[2])) {return 3;}}//leftpath[0].removeAllElements();for(int x=start.getXpos()-1;x>=0;x--) {yx = grid[start.getYpos()][x];xy = grid[end.getYpos()][x];if(yx.isVisible()) break;path[0].add(yx);if(!xy.isVisible()&&ydirect(yx,xy,path[1])&&xdirect(xy,end,path[2])) {return 3;}}//rightpath[0].removeAllElements();for(int x=start.getXpos()+1;x<xBound;x++) {yx = grid[start.getYpos()][x];xy = grid[end.getYpos()][x];if(yx.isVisible()) break;path[0].add(yx);if(!xy.isVisible()&&ydirect(yx,xy,path[1])&&xdirect(xy,end,path[2])) {return 3;}}return 0;}/***在布局中消除配对*/private void deletePair(KyodaiGrid prev, KyodaiGrid current) {//尝试寻找路径//如果找到路径//animateVector temp = new Vector();temp.add(prev);for(int i=0;i<pcount;i++) {temp.addAll(path[i]);path[i].removeAllElements();}AnimateThread thread = new AnimateThread(temp);thread.start();score += progress.getValue()/20;scoreLabel.setText(""+score);progress.setValue(progress.getValue()+60);}/***展示找到的配对*/public void showNext() {if(wingame||progress.getValue()==0||tipcount==0) return;tipcount--;tipLabel.setText(""+tipcount);if(nexts!=null&&nexte!=null) {nexts.setBorder(tipBorder);nexte.setBorder(tipBorder);}}/***删除找到的配对*/public void useBomb() {if(wingame||progress.getValue()==0||bombcount==0) return;bombcount--;bombLabel.setText(""+bombcount);if(nexts!=null&&nexte!=null) {deletePair(nexts,nexte);}}/***发现有连接路径的配对*@返回是否发现*/private boolean findPair() {nexts = null;nexte = null;for(int sy=1;sy<yBound-1;sy++) {for(int sx=1;sx<xBound-1;sx++) {if(!grid[sy][sx].isVisible()) continue;for(int ey=sy;ey<yBound-1;ey++) {for(int ex=1;ex<xBound-1;ex++) {if(!grid[ey][ex].isVisible()||(ey==sy&&ex==sx)) continue;if(grid[sy][sx].getIcon()==grid[ey][ex].getIcon()) {pcount = findPath(grid[sy][sx],grid[ey][ex]);if(pcount!=0) {nexts = grid[sy][sx];nexte = grid[ey][ex];return true;}}}}}}return false;}private class GridMouseAdapter extends MouseAdapter { private KyodaiGrid prev;public void mouseClicked(MouseEvent me) {if(prev == null) {prev = (KyodaiGrid)me.getSource();prev.setBorder(selectedBorder);} else {if(progress.getValue()==0) return;KyodaiGrid current = (KyodaiGrid)me.getSource();if(current == prev) return;if(current.getIcon()==prev.getIcon()) {pcount = findPath(prev,current);if(pcount!=0) {deletePair(prev,current);//setprev = null;return;}}prev.setBorder(opaqueBorder);prev = current;prev.setBorder(selectedBorder);if(!findPair()) refresh();}}}private class AnimateThread extends Thread {private Vector v;public AnimateThread(Vector temp) {v = temp;}public void run() {KyodaiGrid prev = null;KyodaiGrid current;int j = 0;while(j<v.size()) {prev = (KyodaiGrid)v.remove(0);prev.setVisible(true);v.add(prev);j++;try {sleep(20);} catch(InterruptedException ire) {System.err.println("sleep interrupted");}}current = prev;prev = (KyodaiGrid)v.remove(0);while(!v.isEmpty()) {((KyodaiGrid)v.remove(0)).setVisible(false);try {sleep(20);} catch(InterruptedException ire) {System.err.println("sleep interrupted");}}prev.setVisible(false);current.setVisible(false);current.setIcon(ImageFactory.getInstance().getImageicon(39));prev.setIcon(ImageFactory.getInstance().getImageicon(39));current.setBorder(opaqueBorder);prev.setBorder(opaqueBorder);if(!findPair()) refresh();}//end of method run}private class ProgressThread extends Thread {public ProgressThread() {}public void run() {while(true) {while(progress.getValue()>0) {progress.setValue(progress.getValue()-1);try {sleep(100);} catch(InterruptedException ire) {System.err.println("sleep interrupted");}}repaint();suspend();}}}}【总结自己的体会和收获】：通过这次课程设计我学到了不少东西，也发现了大量的问题，同时在设计的过程中也发现了自己的不足之处，对以前学过的知识理解的不够深刻，对安卓手机小游戏的程序编写有了一定的了解。
(完整版)Java连连看毕业课程设计
摘要关键字：发展，java,连连看，程序设计；现代科学技术的发展，改变了人类的生活，作为新世纪的大学生，应该站在时代发展的前沿，掌握现代科学技术知识，以适应社会的发展，能够独立完成面临的任务，作一名有创新意识的新型人才。
Java语言的学习热潮并没有因为时间的推移而消退，相反，由于计算机技术的发展所带来的新应用的出现，Java越来越流行，这种情况是以往程序设计语言在其生存周期内所不多见的。
Java语言之所以这样长盛不衰，一是因为其众多的技术特点与现今的应用十分合拍，可以覆盖大部分的需求；二是因为SUN公司不断推出新的版本，完善Java自身的功能。
有了这两点，Java语言成为程序员首选的程序设计开发工具就在情理之中了。
连连看游戏是一种很流行的小游戏，记得在小时候去游戏厅玩的时候就有两台专门的连连看的机器（当然当时不叫这个名字），一个是连麻将牌、另一个是连水果图片。
当时的麻将牌分好几层，相邻层的牌还可以连，看得人眼花缭乱。
作为一个java初学者，我所编辑的“悠嘻猴连连看”小游戏，只有几个基本功能：“开始”“再来一局”炸弹“重新开始”“退出”。
我所选中给出的游戏界面很漂亮，不过似乎图形只有一层，而且数量也不是很多，只有64张图，降低了不少难度。
目录摘要 (I)第1章需求分析 (1)1.1功能分析 (1)1.2流程图 (2)第2章详细设计 (3)2.1课程设计目的 (3)2.2课程设计的实验环境 (3)2.3课程设计的预备知识 (3)2.4课程设计要求 (3)2.5连连看算法设计 (4)2.6类的实现方法 (4)2.6.1 成员变量 (4)2.6.2 方法设计 (5)第3章测试分析 (7)3.1程序运行情况 (7)3.2测试计划及分析 (9)3.2.1检验的先后顺序 (9)3.2.2程序异常处理 (9)第4章课程设计总结 (10)附件A (1)参考资料 (26)第1章需求分析1.1 功能分析每次用户选择两个图形，如果图形满足一定条件（两个图形一样，且这两个图形之间存在转弯少于3的路径），则两个图形都能消掉。
连连看java代码课程设计
连连看java代码课程设计一、课程目标知识目标：1. 理解Java基本语法，掌握连连看游戏的核心算法；2. 学会使用Java编写图形用户界面，实现游戏窗口的布局与设计；3. 了解Java事件处理机制，能编写鼠标点击事件监听器。
技能目标：1. 培养学生运用Java语言解决实际问题的能力；2. 提高学生分析问题、设计算法、编写代码、调试程序的综合技能；3. 培养学生的创新思维和团队协作能力，通过分组完成任务，提高沟通与协作效率。
情感态度价值观目标：1. 培养学生对编程的兴趣，激发学习积极性，增强自信心；2. 培养学生面对困难时，保持积极的心态，勇于尝试，不断克服挫折；3. 培养学生的集体荣誉感，通过团队协作，共同完成任务，体验成功的喜悦。
分析课程性质、学生特点和教学要求，本课程将目标分解为以下具体学习成果：1. 学生能独立完成连连看游戏的Java代码编写，实现游戏的基本功能；2. 学生能通过小组合作，共同优化游戏界面，提升用户体验；3. 学生在课程学习过程中，能主动探究新知识，勇于挑战更高难度的编程任务；4. 学生在学习过程中，培养良好的编程习惯，注重代码规范和团队协作。
二、教学内容根据课程目标，教学内容主要包括以下几部分：1. Java基本语法：- 数据类型、变量、常量- 运算符、表达式、流程控制（分支、循环）- 数组、字符串2. Java图形用户界面设计：- Swing图形用户界面库简介- JFrame、JPanel容器组件- 布局管理器（边界布局、流布局等）3. Java事件处理机制：- 事件监听器、事件源- 鼠标事件、键盘事件- 事件适配器、事件处理线程4. 连连看游戏核心算法：- 游戏规则、数据结构设计- 算法实现（路径查找、消去逻辑等）- 游戏界面与逻辑分离教学大纲安排如下：1. 第一阶段（2课时）：Java基本语法复习与巩固2. 第二阶段（2课时）：Swing图形用户界面设计3. 第三阶段（2课时）：Java事件处理机制4. 第四阶段（4课时）：连连看游戏核心算法分析与实现教学内容与教材关联章节：1. 《Java程序设计》第3章：Java基本语法2. 《Java程序设计》第6章：Swing图形用户界面设计3. 《Java程序设计》第7章：Java事件处理机制4. 《Java程序设计》实例分析：连连看游戏案例三、教学方法针对本课程的教学目标和内容，采用以下多样化的教学方法：1. 讲授法：- 对于Java基本语法、Swing图形用户界面设计、Java事件处理机制等基础知识点，采用讲授法进行教学，使学生在短时间内掌握必要的理论知识；- 讲授过程中注重启发式教学，引导学生主动思考问题，提高课堂互动性。
JAVA连连看游戏课程设计
JAVA连连看游戏课程设计一、教学目标本课程的目标是让学生掌握Java编程基础，学会使用Java语言编写简单的连连看游戏。
通过本课程的学习，学生应达到以下目标：1.知识目标：–理解Java语言的基本语法和编程概念；–掌握面向对象编程的基本思想和方法；–了解常用的数据结构和算法。
2.技能目标：–能够使用Java语言编写简单的程序；–能够运用面向对象编程思想解决实际问题；–能够独立完成连连看游戏的设计和实现。
3.情感态度价值观目标：–培养学生的编程兴趣和自信心；–培养学生解决问题的能力和创新精神；–培养学生团队协作和沟通交流的能力。
二、教学内容本课程的教学内容主要包括以下几个部分：1.Java语言基础：介绍Java语言的基本语法、数据类型、运算符、控制结构等。
2.面向对象编程：讲解类的定义、属性、方法、继承、多态等概念，并引导学生学会使用面向对象的思想解决问题。
3.常用数据结构和算法：介绍数组、链表、栈、队列等基本数据结构，以及排序、查找等常用算法。
4.连连看游戏设计与实现：引导学生运用所学知识设计和实现一个简单的连连看游戏，包括游戏界面设计、逻辑处理、算法实现等。
三、教学方法本课程采用多种教学方法相结合的方式，以激发学生的学习兴趣和主动性：1.讲授法：教师讲解基本概念、语法和算法，引导学生掌握知识要点。
2.案例分析法：通过分析实际案例，让学生学会运用所学知识解决实际问题。
3.实验法：学生动手编写代码，实践所学知识，培养编程能力和解决问题的能力。
4.小组讨论法：学生分组讨论，共同完成游戏设计，培养团队协作和沟通交流的能力。
四、教学资源本课程所需教学资源包括：1.教材：《Java编程入门》或其他同类教材；2.参考书：《Java核心技术》等；3.多媒体资料：PPT、教学视频等；4.实验设备：计算机、网络等。
教学资源应支持教学内容和教学方法的实施，丰富学生的学习体验，提高学习效果。
五、教学评估为了全面、客观地评估学生的学习成果，本课程采用以下评估方式：1.平时表现：评估学生在课堂上的参与程度、提问回答等情况，以反映学生的学习态度和积极性。
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程序课程设计任务书一、主要任务与目标1、了解图形用户界面的概念；2、了解AWT的基本体系结构，掌握窗口的基本原理；3、掌握几种布局管理器的使用方法；4、掌握java的事件处理机制；5、了解Swing的基本体系结构，掌握Swing组件的使用方法；6、掌握java小程序的工作原理和使用方法；7、该游戏还将设置退出，再来一局按钮，并实现相应的功能。
8、设计一个用户注册登录界面二、主要内容与基本要求游戏规则是模仿网络上普通的连连看游戏，主要是鼠标两次点击的图片能否消去的问题。
当前，前提是点击两张相同的图片，若点击的是同一张图片或者两张不同的图片，则不予处理。
在两张想同图片所能连通的所有路径中，如果存在一条转弯点不多于两个的路径，就可以消去；如果没有，则不予处理。
该游戏由30张不同的图片组成，游戏开始将会出现30张随机组合的图片，在规则下点击两张相同的图片后图片将会消失。
图片全部消完为游戏成功。
游戏还将设置退出，再来一局的按钮，和倒计时的功能，方便用户进行操作。
并且有一个用户登录注册界面，玩家必须登录以后才可以进行游戏。
三、计划进度12月28日~ 12月29日：课程设计选题，查找参考资料12月30日~ 12月31日：阅读参考书籍，收集资料，完成需求分析1月1日~ 1月3日：系统的代码设计及实现，数据库设计与实现1月4日~ 1月5日：系统的调试，修改，完善1月6日~ 1月7日：完成课程设计报告，准备答辩四、主要参考文献[1] 刘宝林.Java程序设计与案例习题解答与实验指导[M].[2] 王鹏何云峰.Swing图形界面开发与案例分析[M].[3]（美）Karl Avedal , Danny Ayers, Timothy Briggs. JSP编程指南[M]. 电子工业出版社, 2004,47-125.[4]（美）Mark Linsenbardt. JSP在数据库中的应用与开发[M]. 希望电子出版社，2005,210-236.[5] Dianne Phelan，Building a simple web database application[C].IEEE InternationalProfessional Communication Conference, 2004, 79-86.[6]（美）Karl Avedal,Danny Ayers,Timothy Briggs.JSP编程指南[M].电子工业出版社,2006,47-125.[7] Dianne Phelan，Building a simple web database application[C].IEEE InternationalProfessional Communication Conference, 2005, 79-86.[8] Altendorf. Eric, Hohman. Moses, Zabicki. Roman. Using J2EE on a large,web-based project[J]. IEEE Software.2002,19(02):81-89.摘要当今社会，休闲型游戏越来越得到人们的喜爱，我所做的毕业设计实例“连连看游戏的设计与实现”是近几年来网络上非常流行的一种二维休闲游戏，它对电脑配置要求不高，娱乐性强，易于上手。
连连看游戏java课程设计
连连看游戏java课程设计一、教学目标本课程的目标是让学生掌握Java编程语言的基本知识，学会使用Java编写简单的图形用户界面程序。
通过本课程的学习，学生将能够理解Java的基本语法，掌握面向对象编程的基本概念，学会使用Java Swing库创建图形用户界面。
具体的学习目标包括：1.理解Java编程语言的基本语法。
2.理解面向对象编程的基本概念，如类、对象、继承、封装和多态。
3.掌握Java Swing库的基本组件和事件处理机制。
4.能够使用Java编写简单的控制台程序。
5.能够使用Java Swing库创建图形用户界面程序。
6.能够调试和运行Java程序。
情感态度价值观目标：1.培养学生的编程兴趣，提高学生对计算机科学的热爱。
2.培养学生团队合作的精神，学会与人合作解决问题。
3.培养学生的创新意识，鼓励学生积极探索和创造。
二、教学内容本课程的教学内容主要包括Java编程语言的基本语法、面向对象编程的概念以及Java Swing库的使用。
具体的教学大纲如下：1.第一章：Java编程语言的基本语法–数据类型和变量–运算符和表达式2.第二章：面向对象编程–继承和多态3.第三章：Java Swing库–Swing组件4.第四章：连连看游戏的设计与实现–游戏逻辑的设计–游戏界面的设计–游戏功能的实现三、教学方法为了激发学生的学习兴趣和主动性，本课程将采用多种教学方法，包括讲授法、讨论法、案例分析法和实验法。
1.讲授法：教师通过讲解和示范，向学生传授Java编程语言的基本语法和概念。
2.讨论法：学生分组讨论问题，培养团队合作和沟通能力。
3.案例分析法：分析具体的案例，让学生理解Java Swing库的使用和图形用户界面的设计。
4.实验法：学生动手编写代码，实现连连看游戏，培养学生的实际编程能力。
四、教学资源为了支持教学内容和教学方法的实施，本课程将使用以下教学资源：1.教材：《Java编程语言》2.参考书：《Java Swing教程》3.多媒体资料：教学PPT、视频教程4.实验设备：计算机、网络环境以上教学资源将帮助学生更好地学习Java编程语言，掌握连连看游戏的设计与实现，提高编程能力和创新意识。
JAVA课程设计—连连看最终版要点
JAVA课程设计报告实验题目：“连连看”游戏程序设计小组成员：王飞铭、毛建平、陈银银、黄庭威成员分工：组长：王飞铭王飞铭：actionPerformed（）：重来一局按钮的响应事件及remove（）判断移去方法毛建平：xiao()消去方法、estimateEven（）方法陈银银：init()方法：游戏主界面和main（）方法实现产生随机数方法、fraction()刷新黄庭威：randomBuild()方法（一）：内容：1：功能需求和分析：（1）该游戏界面为：数字方格类型，由6竖7横的直线平行垂直交叉而组成，分别是6行5列凹方块拼接，共有30格小方块。
方块上随机分布一些数字，数字的要求是至少两两相同，位置随机打乱。
（2）游戏规则是：将相同数字的方块连接，但要满足只能至少单边无阻碍呈直线趋势连接，否则视为无效，如果一对数字连接成功，那么就会消失在界面，并且分数标签会加分，继续游戏，直到游戏结束。
（3）帮助项目：在游戏过程中，如果出现没有可以连接的数字对时候，可按界面下方按钮刷新重新排列，便可以可继续游戏。
（4）退出游戏：可以鼠标点击“退出”按钮，结束游戏。
（5）再来一局：本局结束或者中途不想继续玩本局，可以点击界面下方的再来一局，系统会自动再次重新开始。
（二）：主要方法：首先我们定义了一个lianliankan类，实现了接口ActionListener：1)init()方法：实现游戏主界面；2)randomBuild()方法：用来产生游戏按钮上的随机数；3) fraction()方法：游戏界面最上面用来加分；4)reload()方法：用来刷新，重载，窗体界面；5)estimateEven（）方法：判断按钮数字是否满足消去的条件linePassOne()方法：判断第一按钮同左右侧空按钮之间⑦rowPassOne()方法：判断第一按钮同列空按钮与第二按钮；6)actionPerformed(ActionEvent e)方法：用来实现重来一局按钮的响应事件；7)main(String[] args)方法：主函数；8)xiao()方法：消去方法（三）：界面要求：用图形界面实现，参考下系统流程图如下NO（四）：代码设计package数字版;/**本游戏是连连看，上面出现的都是数字，点击两个相邻的或者之间没有第三个的，便可以消去。
连连看Java小游戏毕业设计论文
版本更新信息
本文档的更新记录如表A-1。
表A-1 版本更新记录
修改编号
修改日期
修改后版本
修改位置
修改内容概述
001
0.1
全部
初始发布版本
2系统定义
我们分别阐述一下项目的来源、背景和项目的目标。
项目来源及背景
本项目的是是您的生活不再乏味，让你看到自己的智慧和天赋，使自己对自己更加充满信心。相信通过此游戏会让你看到自己聪明的一面。现在生活忙忙碌使人的心理和身体健康受到很大的威胁。为了解决些问题特此开发了连连看小游戏。
northPanel.add(fractionLable);
mainFrame.setBounds(280,100,500,450);
mainFrame.setVisible(true);
}
2.产生随基数：
public void randomBuild() {
int randoms,cols,rows;
centerPanel=new JPanel();
southPanel=new JPanel();
northPanel=new JPanel();
thisContainer.add(centerPanel,"Center");
thisContainer.add(southPanel,"South");
while(grid[cols][rows]!=0) {
cols=(int)(Math.random()*6+1);
rows=(int)(Math.random()*5+1);
}
this.grid[cols][rows]=randoms;
java实现连连看课程设计
java实现连连看课程设计一、课程目标知识目标：1. 掌握Java编程语言的基本语法和结构；2. 理解面向对象编程思想，能够运用类和对象进行程序设计；3. 学会使用Java中的数组存储和管理数据；4. 掌握Java图形用户界面编程，实现连连看游戏的界面设计和布局。
技能目标：1. 能够运用所学知识，独立完成连连看游戏的编写和调试；2. 提高问题分析能力，学会将实际问题转化为计算机程序；3. 培养逻辑思维和编程实践能力，提高编程效率。
情感态度价值观目标：1. 培养学生对编程的兴趣，激发学习积极性；2. 培养学生的团队协作精神，学会与他人合作解决问题；3. 增强学生的自信心，勇于面对挑战，克服困难；4. 培养学生严谨、细心的学习态度，养成良好的编程习惯。
课程性质：本课程为信息技术学科的一节实践性课程，结合连连看游戏的开发，让学生在实践中掌握Java编程知识。
学生特点：学生处于八年级，具备一定的信息技术基础，对编程有一定的了解，但实践经验不足。
教学要求：注重理论与实践相结合，充分调动学生的积极性，引导学生主动参与课堂讨论和实践操作。
通过完成连连看游戏项目，培养学生的编程能力和解决问题的能力。
在教学过程中，关注学生的个体差异，给予个性化指导，确保每个学生都能达到课程目标。
将课程目标分解为具体的学习成果，以便进行教学设计和评估。
二、教学内容1. Java基本语法与结构复习：回顾变量、数据类型、运算符、控制语句等基础知识，确保学生具备编写Java程序的基础能力。
教材章节：第一章 Java语言概述及基础语法。
2. 面向对象编程：介绍类与对象的概念，理解封装、继承、多态等面向对象特性，并通过实例演示如何运用。
教材章节：第二章 面向对象编程。
3. 数组的使用：讲解数组的定义、初始化、遍历和应用，为游戏数据存储打下基础。
教材章节：第三章 数组与字符串。
4. Java图形用户界面编程：介绍Swing库的基本组件，重点讲解容器、布局管理器和事件处理机制。
JAVA实现连连看课程设计
目录第一章系统描述............... ............... .. (1)第二章分析与设计............... ............... (2)一、功能分析............. ............... . (2)二、流程图............. ............... (2)三、设计要求............. ............... . (3)1、实验环境............. ............... .. (3)2、实验预备知识............. ............... . (3)3、课程设计要求............. ............... . (3)第三章连连看系统设计............. ............... (4)一、算法设计............. ............... .. (4)二、类的实现............. ............... .. (5)三、方法的实现............. ............... (5)第四章测试分析............. ............... (5)一、运行情况............. ............... .. (5)二、测试计划及分析............. ............... .. (9)1、检验的先后顺序............. ............... .. (9)2、程序异常处理............. ............... . (9)第五章心得体会............. ............... .. (10)第六章参考文献............. ............... .. (11)附件............. ............... . (11)第一章系统描述近年来，Java作为一种新的编程语言，以其简单性、可移植性和平台无关性等优点，得到了广泛地应用，特别是Java与万维网的完美结合，使其成为网络编程和嵌入式编程领域的首选编程语言。
连连看小游戏设计毕业设计
摘要游戏“连连看”，只要将相同花色的两张牌用三根以内的直线连在一起就可以消除，规则简单容易上手。
这个程序的界面使用Jframe框架，主程序窗口包含一个主面板，其中包含两个子面板，左边一层子面板是游戏窗口，符合我们玩游戏的习惯，包含连连看游戏的图片元素，用户进行游戏能找到32对图片；右边一层用来实现游戏控制，有开始、刷新、选择难度、显示分数、进度条等功能选项。
结合Java 编程语言的简单、面向对象、分布式、解释性、健壮、安全与系统无关、可移植、高性能、多线程、动态和连连看游戏的休闲、趣味、益智加上美观的界面设计和秀色可餐的水果蔬菜游戏图片元素，使这款连连看游戏成为现代都市人们打发无聊，放松身心的好帮手。
加入了游戏时间控制和过关控制及进度条提示功能使游戏速度节奏快，画面清晰可爱，老少皆宜。
通过ActionEvent 组件进行动作事件的监听和处理。
游戏通过定义数组，根据一定的算法实现规定的路径判断。
关键字： Java连连看；Jframe；数组；路径判断AbstractThe game "lianliankan", as long as the two cards with the same suit straight up to three connected can be eliminated, rules are easy. This program of interface using Jframe framework, main program window contains a a main panel, which contains two a child Panel, left a layer child Panel is game window, meet we playing game of habits, contains fest see game of pictures element, user for game can found 32 on pictures; right a layer used to achieved game control, has began, and refresh, and select difficulty, and displayed score, and progress article, features option. Combines a simple Java programming language, object-oriented, distributed, interpreted, robust, secure system-independent, portable, high-performance, multithreaded, dynamic and lianliankan games, leisure, fun, puzzle together with attractive interface design and appetizing fruit vegetables picture elements, makes this lianliankan games become the modern city spending tedious, relaxed and good help. Joined the playing time control and border control and progress bar prompts make the game faster tempo, clear picture and lovely, both young and old. Action through the ActionEvent component event listening and handling. Games by defining an array according to certain algorithms provide path of judgment.Key words: Java Lianliankan ; Jframe ; array ; approaches目录1.引言 (1)2.游戏规则 (1)2.1概要 (1)2.2操作 (1)2.3胜利条件 (1)2.4失败条件 (1)3.发展概况 (1)3.1连连看游戏的历史 (1)3.2用java语言写连连看游戏的原因 (2)4.方案论证 (2)4.1设计原理 (2)4.2方案选择 (3)4.3主要问题 (3)4.4技术要求 (3)4.5游戏应用环境的构建 (4)5.系统分析 (4)5.1模块分析 (4)5.1.1 界面的设计和图片的随机生成模块 (5)5.1.2 菜单控制模块 (5)5.1.3算法模块 (5)5.2基本思路 (6)5.2.1 游戏地图设计思路 (6)5.2.2 连连看游戏图片 (6)5.2.3 获取图片位置 (6)5.2.4 路径判断思路 (7)6.系统设计 (8)6.1主界面的设计 (8)6.2图片的随机生成 (9)6.3单击控件的事件触发 (9)6.3.1开始游戏按钮 (9)6.3.2重列按钮 (10)6.3.3难度选择按钮 (10)6.4清除两个一样的符合条件的方块 (10)6.5过关设置 (10)7.结果分析 (11)7.1优点 (11)7.2缺点 (11)8.总结 (11)参考文献 (13)致谢 (14)1.引言网络小游戏、网页游戏越来越受网民欢迎，除了玩的方法简单外（不像其他游戏还需要注册下载繁琐过程），很多游戏不乏经典。
Java连连看程序代码
Button p1,p2,br,bt1,bt2; //p1、p2为选定的按钮
Panel panel1,panel2;
int d[][]={ //用来和界面的按钮建立映射关系
{0,0,0,0,0,0,0},
{0,0,0,0,0,0,0},
{0,0,0,0,0,0,0},
{0,0,0,0,0,0,0},
{0,0,0,0,0,0,0},
{0,0,0,0,0,0,0},
{0,0,0,0,0,0,0},
{0,0,0,0,0,0,0}
};
public static void main(String[] args)
panel1.add(b7); panel1.add(b8); panel1.add(b9);
panel1.add(b10); panel1.add(b11); panel1.add(b12);
panel1.add(b13); panel1.add(b14); panel1.add(b15);
b4=new Button(String.valueOf(d[1][4]));
b5=new Button(String.valueOf(d[1][5]));
b6=new Button(String.valueOf(d[2][1]));
b7=new Button(String.valueOf(d[2][2]));
{0,0,0,0,0,0,0}
};
this.d=d;
suiji(); //调用随机函数，产生随机数;
f.setVisible(false);
连连看java课程设计
连连看java课程设计一、课程目标知识目标：1. 理解Java语言的基本语法和程序结构；2. 掌握连连看游戏的逻辑设计和实现方法；3. 学会使用Java编程解决实际问题。
技能目标：1. 能够运用Java语言编写连连看游戏的界面和功能；2. 能够运用条件语句和循环语句实现游戏逻辑；3. 能够运用数组管理游戏数据，提高编程能力。
情感态度价值观目标：1. 培养学生对编程的兴趣，激发学习积极性；2. 培养学生解决问题的能力，增强自信心；3. 培养学生团队协作意识，提高沟通能力。
课程性质：本课程为实践性较强的Java编程课程，通过设计并实现连连看游戏，让学生在实践中掌握Java编程技能。
学生特点：学生具备一定的Java基础，对编程感兴趣，喜欢动手实践。
教学要求：结合学生特点和课程性质，注重理论与实践相结合，以学生为主体，充分调动学生的积极性和创造性。
将课程目标分解为具体的学习成果，以便于后续教学设计和评估。
二、教学内容1. Java基本语法复习：变量、数据类型、运算符、控制结构；2. 面向对象基础：类与对象、构造方法、成员变量、成员方法；3. 数组的使用：声明、初始化、遍历、排序；4. Java Swing图形用户界面：窗体、按钮、标签、布局管理器；5. 事件处理机制：事件监听器、事件适配器；6. 连连看游戏逻辑设计：游戏规则、数据存储、界面设计；7. 游戏功能实现：随机生成、匹配消除、计分与计时；8. 游戏测试与优化：功能测试、性能优化、用户体验。
教学内容安排与进度：第一课时：Java基本语法复习，面向对象基础；第二课时：数组的使用，Java Swing图形用户界面；第三课时：事件处理机制，连连看游戏逻辑设计；第四课时：游戏功能实现，测试与优化。
教学内容与教材关联：本教学内容与《Java编程思想》第四章至第七章内容相关，涉及基本语法、面向对象、数组和Swing图形用户界面等方面的知识。
通过本章节学习，学生能够将所学理论知识运用到实际项目中，提高编程实践能力。
Java课程连连看游戏开发文档
开发文档一：需求分析：1.简单易学的鼠标操作以及简单通俗的游戏规则，使广大的用户不需要专门进行培训，就可以立即学会如何使用。
2.直连相消:两个相消块在同一行或同一列，并且可以相消;单拐相消:两个相消块经过一个转弯，可以相消;双拐相消:两个相消块经过两个转弯，可以相消;3．有倒计时功能。
二：类图:GameFuction类：GameDate类：分数计算GameRule类：Main类：MainFrame类：（游戏窗口）（重点）游戏规则，判断是否满足条件构造方法相关的类时间控制，三：主要模块的流程图：界面流程：时间控制，时间条图片加载事件处理整体流程：四：开发过程中遇到的主要问题和解决办法：主要问题：1.是如何出来一个连连看游戏初始布局，保证这些水果随机分配；2.倒计时代码以及出现的位置；3.在规定时间完成游戏后跳出“恭喜你获胜”；解决办法：1.百度寻求答案（出现错误的概率较高，有的问题找不到答案）2.书在上找出现的类似的问题，进行对比检验；3.询问老师。
五：未实现的的需求及原因：未实现的需求：1.玩游戏时的背景音乐；2.用户界面的美化；3.倒计时显示的位置以及状态；原因：1.有待研究；2.学习不通透，有的需求实现不了；六：总结：整个项目做下来，问题挺多的主要是各科还在备考阶段，每个人的时间分配也不一样。
第一次和小组成员一起完成一个游戏项目。
虽然不是独立完成的，但是我们也学到了很多，最后运行结果出来的时候，每个人都特别有满足感。
其实整个项目下来，我们也查了特别多的资料，在改游戏代码阶段才觉得java里的小知识点太多了，通过这个游戏项目，我们也学会了挺多知识，整个下来学会了查资料以及排错，总体感觉还是不错的，主要还是项目需求分析不明确，常常做着做着不知道做什么了，当然，光想不做是不行的，做程序要务实，不想就做也不好。
课程设计报告Java实现游戏连连看(有源代码)
2.4流程图如下图2 主函数流程图图3 游戏进行流程图图4 使用炸弹流程图图5 计算时间流程图图6 开始游戏后画面用户选择两张一样的图片，通过鼠标进行选取，如果用户两次点击的图片不相同，那么系统认为用户没有点（鼠标记数归0），以完成用户以后的选取工作。
如果用户选择的是相同的图片（如第八行第二列和第八行第三列），那么系统会消除这两张图片，并使鼠标记数为0，并消除这两张图片的标记，使里面的图片被标记在外面。
以便用户可以进行以后的选择。
图7 消除三对后画面用户也可使通过使用“炸弹”功能进行消除图片。
方法是点击菜单中的“炸弹”选项使用，点击后如果界面上有两张可以相连的相同图片就随机消除两张可以相连的相同的图片（如第一行第一列河第一行第四列）。
图8 使用炸弹后画面炸弹数目是有限的，默认数目为三，每使用一次“炸弹”功能，炸弹数目就会自动减一，当炸弹数目为零时（使用三次“炸弹”功能）。
并且用户想再次使用炸弹时，系统会弹出对话框提示用户，并把菜单中“炸弹”选项变为灰色（用户不可使用）。
图9 炸弹使用光后画面当系统开始游戏后，系统会在后台记录时间，如果在用户还没有消除所有图片时，系统时间到了，那么系统会弹出对话框，提示用户，时间到了，游戏失败。
图10 时间到时的画面当用户点击确定后，系统还会弹出对话框询问用户是否重新开始，用户选择“是”时，系统会开始新游戏；当用户选择“否”时，系统会返回开始界面；当用户选择“取消”时，系统会返回提示时间到的界面。
图11 点击确定时的画面如果在时间未到时，用户使所有的图片都消失（两两消除，直到最后一对），系统会提示用户游戏以通过，点“确定”后回到开始界面。
图12 通关画面4.设计体会通过这次课程设计我学到了不少东西，也发现了大量的问题，同时在设计的过程中发现了自己的不足之处，对以前所学过的知识理解得不够深刻，掌握得不够牢固。
因而，通过课程设计之后，把以前所学过的知识重新温故。
有些在设计过程中已解决，有些还有待今后慢慢学习，只要认真学就会有更多的收获。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
Java程序课程设计任务书一、主要任务与目标1、了解图形用户界面的概念；2、了解AWT的基本体系结构，掌握窗口的基本原理；3、掌握几种布局管理器的使用方法；4、掌握java的事件处理机制；5、了解Swing的基本体系结构，掌握Swing组件的使用方法；6、掌握java小程序的工作原理和使用方法；7、该游戏还将设置退出，再来一局按钮，并实现相应的功能。
8、设计一个用户注册登录界面二、主要内容与基本要求游戏规则是模仿网络上普通的连连看游戏，主要是鼠标两次点击的图片能否消去的问题。
当前，前提是点击两张相同的图片，若点击的是同一张图片或者两张不同的图片，则不予处理。
在两张想同图片所能连通的所有路径中，如果存在一条转弯点不多于两个的路径，就可以消去；如果没有，则不予处理。
该游戏由30张不同的图片组成，游戏开始将会出现30张随机组合的图片，在规则下点击两张相同的图片后图片将会消失。
图片全部消完为游戏成功。
游戏还将设置退出，再来一局的按钮，和倒计时的功能，方便用户进行操作。
并且有一个用户登录注册界面，玩家必须登录以后才可以进行游戏。
三、计划进度12月28日~ 12月29日：课程设计选题，查找参考资料12月30日~ 12月31日：阅读参考书籍，收集资料，完成需求分析1月1日~ 1月3日：系统的代码设计及实现，数据库设计与实现1月4日~ 1月5日：系统的调试，修改，完善1月6日~ 1月7日：完成课程设计报告，准备答辩四、主要参考文献[1] 刘宝林.Java程序设计与案例习题解答与实验指导[M].[2] 王鹏何云峰.Swing图形界面开发与案例分析[M].[3]（美）Karl Avedal , Danny Ayers, Timothy Briggs. JSP编程指南[M].电子工业出版社,.[4]（美）Mark Linsenbardt. JSP在数据库中的应用与开发[M]. 希望电子出版社，.[5] Dianne Phelan，Building a simple web database application[C].IEEEInternational Professional Communication Conference, 2004, 79-86.[6]（美）Karl Avedal,Danny Ayers,Timothy Briggs.JSP编程指南[M].电子工业出版社.[7] Dianne Phelan，Building a simple web database application[C].IEEEInternational Professional Communication Conference, 2005, 79-86.[8] Altendorf. Eric, Hohman. Moses, Zabicki. Roman. Using J2EE on alarge, web-based project[J]. IEEE Software. (02):81-89.摘要当今社会，休闲型游戏越来越得到人们的喜爱，我所做的毕业设计实例“连连看游戏的设计与实现”是近几年来网络上非常流行的一种二维休闲游戏，它对电脑配置要求不高，娱乐性强，易于上手。
此次设计所使用的语言为Java语言，开发环境为JCreator。
主要应用到Swing组件，Java小程序，事件及接口等。
这些接口为游戏的制作提供了便捷的条件，本系统的主要特点就是运用Swing组件和事件处理技术，进行界面的绘制，鼠标的操作，以及积分的显示等功能。
这次通过连连看的设计开发将对理解Swing组件技术以及事件处理技术在游戏方面的应用起到很大的帮助作用，同时为掌握Java编程技术及二维休闲游戏设计的一般方法打下坚实的基础。
本文阐述了实例“连连看”的设计思想和实现。
全文分为五章。
第一章对选题的背景及项目的功能进行了简要叙述。
第二章介绍了开发本系统所使用的Java语言、Swing组件和事件处理技术。
第三章介绍了系统的需求分析。
第四章则对游戏的各功能模块及实现算法等详细设计进行了介绍。
第五章对程序运行与调试中经历的问题和学到的编程及游戏设计经验进行总结。
关键词：游戏，连连看，二维游戏ABSTRACTToday's society, Casual games get more and more popular among people, I did graduate design example, "Design and Implementation Lianliankan game" is very popular in recent years the network of atwo-dimensional casual games. Its less demanding computer configuration, Entertaining, Easy to fly.The language used in graduate design language for the Java, Development environment for the JCreator . Mainly applied to the Microsoft Swing framework provides more documentation procedures and events functions to interface. The game interface offers convenient conditions for production, The main features of this system is to use events framework and interface technology to interface mapping, mouse operations, and display functions standings.The design and development by Lianliankan Swing framework will understand the technology and the events application of technology in the games played very of the general method of game design and lay a solid foundation.In this paper, examples of "Lianliankan" The design and implementation. Paper is divided into five chapters. Chapter I of the project background and project a brief description of the function. Thesecond chapter describes the development of this system uses Javalanguage, Swing framework of the technology and Event interfacetechnology. The third chapter describes the system requirements analysis.The fourth chapter of the game's various function modules and thedetailed design algorithm was introduced. Chapter V of the program isrunning and debugging the problems experienced and learnedprogramming and game design experience summary.Keywords: Games，Lianliankan，two-dimensional game目录JAVA程序课程设计任务书 (II)摘要 (III)ABSTRACT (V)目录 (VI)第1章引言 (1)1.1背景 (1)1.2课程设计内容 (1)1.3任务分工 (2)2章连连看游戏界面 (3)2.1连连看游戏概述 (3)2.1.1 连连看游戏的规则 (3)2.1.2连连看胜利与失败条件 (4)2.2连连看系统介绍 (4)2.3本章小结 (5)第3章连连看游戏的设计 (6)3.1系统需求分析 (6)3.2系统开发及运行环境 (6)3.3系统主要功能要求 (7)3.4.1 连连看系统总体结构 (7)3.4.2 连连看系统各模块介绍 (8)3.5本章小结 (9)第4章系统的具体实现 (10)4.1界面设计 (10)4.1.1用户登陆界面图 (10)4.1.2注册界面 (13)4.1.3系统界面 (16)4.1.4执行界面 (17)4.2程序设计及调试运行 (26)4.2.1游戏的连接算法 (26)4.2.3 JFreeChart (29)第5章结束语 (31)致谢 (32)参考文献 (33)附录源代码 (34)第1章引言1.1 背景游戏“连连看”顾名思义就是找出相关联的东西，这个连连看在网上基本是用在小游戏中，就是找出相同的两样东西，在一定的规则之内可以做为相关联处理。
“连连看”的发展经历了从桌面游戏、在线游戏、不同版本连连看游戏(12张)社交游戏三个过程。
游戏“连连看”是源自台湾的桌面小游戏，自从流入大陆以来风靡一时，也吸引众多程序员开发出多种版本的“连连看”。
这其中，顾方编写的“阿达连连看”以其精良的制作广受好评，这也成为顾方“阿达系列软件”的核心产品。
并于2004年，取得了国家版权局的计算机软件著作权登记证书。
随着Flash应用的流行，网上出现了多种在线Flash版本“连连看”。
如“水晶连连看”、“果蔬连连看”等，流行的“水晶连连看”以华丽界面吸引了一大批的女性玩家。
2008年，随着社交网络的普及和开放平台的兴起，“连连看”被引入了社交网络。
“连连看”与个人空间相结合，被快速的传播，成为一款热门的社交游戏，其中以开发者Jonevey在Manyou开放平台上推出的“宠物连连看”最为流行。
现在网络小游戏、网页游戏越来越受网民欢迎，除了玩的方法简单外（不像其他游戏还需要注册下载繁琐过程），很多游戏不乏经典。
连连看游戏就是典型。