java连连看简短代码 java 连连看

求1个java连连看说明文档

我帮你分析了一下，把程序的思路帮你了出来，难理解的地方也写了出来，看看吧：

创新互联是一家集网站建设,大宁企业网站建设,大宁品牌网站建设,网站定制,大宁网站建设报价,网络营销,网络优化,大宁网站推广为一体的创新建站企业，帮助传统企业提升企业形象加强企业竞争力。可充分满足这一群体相比中小企业更为丰富、高端、多元的互联网需求。同时我们时刻保持专业、时尚、前沿，时刻以成就客户成长自我，坚持不断学习、思考、沉淀、净化自己，让我们为更多的企业打造出实用型网站。

/*

* 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();

}

}

怎么用java写一个小游戏连连看

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();

}

}

用java语言编写连连看游戏

我以前自己写一个玩的。没有把你要求的功能全部实现，不过你看了后可以改一下就好了。参考一下吧，我给了注解：

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();

}

}

连连看JAVA源代码

加上。(初始化代码楼主清洗本身选) 对应在这句话。别离grid[][]数组的行列即可，你只需定义25个不一样的图片;后面; 这句话是用来设置连连看的图的.setIcon(icons[grid[cols + 1][rows + 1])])。 定义： diamondsButton[cols][rows] = new JButton(String .valueOf(grid[cols + 1][rows + 1]))： ImageIcon icons[]= new ImageIcon[25]： diamondsButton[cols][rows].valueOf(grid[cols + 1][rows + 1]))diamondsButton[cols][rows] = new JButton(String 。它只用了数字; 然后把icons数组初始化对应每个图片即可

网站标题：java连连看简短代码 java 连连看
网站地址：http://scjbc.cn/article/doesggi.html