Java五子棋代码

设计思路：

本程序主要采用以下三种技术：(1)Swing编程;(2) ImageIO类的使用;(3) Graphics 图片的绘制

对于这样一个五子棋游戏程序。

1. 首先我们需要使用java.Swing和java.awt工具包来设计游戏的用户界面，绘制图像图形，比如制作棋盘。

2. 另外ImageIO类还用于导入和显示图片作为游戏界面的背景。背景图片可以自己设计。

3. 主界面制作完成后，我们可以添加事件监听，使用鼠标监听相关的类MouseListener在指定区域和位置点击生成棋子进行下棋。

4. 接下来，我们可以设计算法来确定获胜者。

5. 然后实现按键功能。

6. 最后调试测试看看程序有没有bug。

编程过程

导入 java.awt 、 java.io 和 javax.swing 工具包，其中包含用于创建用户界面、绘制图形图像、导入图像和监控鼠标的所有类.

导入 java.awt.Color；//颜色类用于为游戏界面着色
导入java.awt.Font；//字体类提供字体相关的类和接口。
导入 java.awt.Graphics；//Graphics类提供了执行绘图、着色、文本输出等实际操作功能的基类
导入 java.awt.Toolkit；
导入 java.awt.event.MouseEvent；
导入 java.awt.event.MouseListener；//监听鼠标相关的类
导入 java.awt.image.BufferedImage；//导入图片的处理类
导入java.io.File；// 文件和目录路径名的抽象表示。
导入 java.io.IOException；//异常类
导入 javax.imageio.ImageIO；//显示图片的类
导入 javax.swing.JFrame；//创建一个表单并设置它的大小、位置等属性
导入 javax.swing.JOptionPane；//对话框相关类

设计游戏主窗口

公共类 FiveChessFrame 扩展 JFrame 实现 MouseListener，Runnable {
	// 获取屏幕的宽高，计算合适的位置使游戏界面居中
	int width = Toolkit.getDefaultToolkit().getScreenSize().width;
	int height = Toolkit.getDefaultToolkit().getScreenSize().height;
	// 首先定义背景图片为空
	缓冲图像 bgImage = null;
	//这里定义的X和Y用于保存棋子的坐标
	诠释 x = 0;
	整数 y = 0;	
   /** 定义一个19*19的二维数组来表示棋盘，其中数据内容0：表示该点没有棋盘，1：表示该点为黑色，2：表示该点是白色的*/
	int[][] allChess = new int[19][19];
	// 判断下一步是黑棋还是白棋
	布尔 isBlack = true;
	// 判断当前游戏是否可以继续
	boolean canPlay = true;
	// 保存显示的提示信息，用于显示在界面棋盘上方
	String message = "黑色优先";	
	//设置五子棋游戏界面的主窗口（位置、大小、中心显示等属性）
       公共 FiveChessFrame() {
	   this.setTitle("五子棋--曾雷");
		this.setSize(500, 500);
		this.setLocation((宽度 - 500) / 2, (高度 - 500) / 2);
		this.setResizable(false);
		// 设置窗体的关闭方式为默认，程序将结束
		this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
		// 向窗体添加鼠标侦听器
		this.addMouseListener(this);
		// 显示表格
		this.setVisible(true);
	/**下面是导入预先设计好的图片作为游戏界面的背景，应用于io流操作。背景图片通过ImageIo类从磁盘导入到程序中，使用try IOException捕捉异常*/
		尝试 {
			bgImage = ImageIO.read(new File("E:\\image\\128.jpg"));
		} 捕捉（IOException e）{
				e.printStackTrace();
		}
		// 刷新屏幕防止游戏无显示启动
		this.repaint();
	}

画棋盘

公共无效油漆（图形g）{
		// 绘制背景
		g.drawImage(bgImage, 1, 20, 这个);
		// 输出标题信息
		g.setFont(new Font("Blackbody", Font.BOLD, 20));
		g.drawString(" : " + 消息, 130, 60);		
       /**画棋盘，在流出背景图片的棋盘区域画出棋盘的线，用for循环画棋盘的线，扫所有18个相等的点，很容易计算*/
		for (int i = 0; i < 19; i++) {
			g2.drawLine(10, 70 + 20 * i, 370, 70 + 20 * i);
			g2.drawLine(10 + 20 * i, 70, 10 + 20 * i, 430);
		}
   /** 使用Graphics类的fillOver方法标记棋盘上的九个点（只显示一个，其余类似），可以先用鼠标监听得到点的坐标，然后绘制*/
		g2.fillOval(68, 128, 4, 4);
	/**下面提供了绘制棋子的程序代码，即通过鼠标监听器判断出在什么位置的棋子的颜色。参数传递 1 为黑色，2 为白色。*/
		for (int i = 0; i < 19; i++) {
			for (int j = 0; j < 19; j++) {
				if (allChess[i][j] == 1) {
					int tempX = i * 20 + 10;
					int tempY = j * 20 + 70;
					g2.fillOval(tempX - 7, tempY - 7, 14, 14);
				}
				if (allChess[i][j] == 2) {
					int tempX = i * 20 + 10;
					int tempY = j * 20 + 70;
					g2.setColor(Color.WHITE);
					g2.fillOval(tempX - 7, tempY - 7, 14, 14);
					g2.setColor(Color.BLACK);
					g2.drawOval(tempX - 7, tempY - 7, 14, 14);
				}
			}
		}
		g.drawImage(bi, 0, 0, 这个);
	}

添加鼠标监视器

公共无效鼠标按下（鼠标事件e）{
		如果（可以播放 == 真）{
			x = e.getX();
			y = e.getY();
			如果 (x >= 10 && x <= 370 && y >= 70 && y <= 430) {
				x = (x - 10) / 20;
				y = (y - 70) / 20;
				if (allChess[x][y] == 0) {
				if (isBlack == true) {
						所有国际象棋[x][y] = 1;
						isBlack = 假；
						message = "轮到白芳了";
					} 别的 {
						所有国际象棋[x][y] = 2;
						isBlack =真；
						message = "黑色方块";
					}
					// 判断该棋子是否与其他棋子连接5，即判断游戏是否结束
					boolean winFlag = this.checkWin();
					如果（winFlag == true）{
						JOptionPane.showMessageDialog(this, "game over,"
								+ (allChess[x][y] == 1 ? "Black Square" : "Baifang") + "胜利！");
						可以播放=假；
					}
				} 别的 {
					JOptionPane.showMessageDialog(this, "当前位置有棋子，请再放下！");
				}
				this.repaint();
			}
		}

给每个按钮对应的功能

赋予开始游戏按钮相应的功能。点击“开始游戏”。如果要重新开始游戏，清除棋盘，将allchess中的数据清零，将“游戏信息”显示改回初始状态，将下一局游戏改为黑色方块

如果 (e.getX() >= 400 && e.getX() <= 470 && e.getY() >= 70
				&& e.getY() <= 100) {
		int result = JOptionPane.showConfirmDialog(this, "你想重启游戏吗？");
		如果（结果 == 0）
		   allChess = new int[19][19];
		message = "黑色优先";
			isBlack =真；
				this.repaint();
			}
		}

赋予“退出游戏”按钮对应功能

如果 (e.getX() >= 400 && e.getX() <= 470 && e.getY() >= 370
				&& e.getY() <= 400) {
			JOptionPane.showMessageDialog(this, "game over");
			System.exit(0);
		}
	}

赋予“游戏设置”按钮功能

如果 (e.getX() >= 387 && e.getX() <= 496 && e.getY() >= 228
				&& e.getY() <= 261) {
			字符串输入 = JOptionPane
					.showInputDialog("请输入游戏的最大时间(公司：分钟)，如果输入0，则无时间限制：");
			尝试 {
				maxTime = Integer.parseInt(输入) * 60;
				如果（最大时间 < 0）{
					JOptionPane.showMessageDialog(this, "请输入正确信息，不允许输入负数！");
				}
				如果（最大时间 == 0）{
					int 结果 = JOptionPane.showConfirmDialog(this,
							"设置完成，要重新开始游戏吗？");
					如果（结果 == 0）{
						for (int i = 0; i < 19; i++) {
							for (int j = 0; j < 19; j++) {
								所有国际象棋[i][j] = 0;
							}
						}
						// 另一种方式是 allChess = new int[19][19];
						message = "黑色优先";
						isBlack =真；
						黑色时间 = 最大时间；
						白色时间 = 最大时间；
						blackMessage = "无限";
						whiteMessage = "无限";
						this.canPlay = true;
						this.repaint();
					}
				}
				如果（最大时间> 0）{
					int 结果 = JOptionPane.showConfirmDialog(this,
							"设置完成，要重新开始游戏吗？");
					如果（结果 == 0）{
						for (int i = 0; i < 19; i++) {
							for (int j = 0; j < 19; j++) {
								所有国际象棋[i][j] = 0;
							}
						}
						// 另一种方式是 allChess = new int[19][19];
						message = "黑色优先";
						isBlack =真；
						黑色时间 = 最大时间；
						白色时间 = 最大时间；
						blackMessage = maxTime / 3600 + ":"
								+ (maxTime / 60 - maxTime / 3600 * 60) + ":"
								+ (maxTime - maxTime / 60 * 60);
						whiteMessage = maxTime / 3600 + ":"
								+ (maxTime / 60 - maxTime / 3600 * 60) + ":"
								+ (maxTime - maxTime / 60 * 60);
						t.resume();
						this.canPlay = true;
						this.repaint();
					}
				}
			} 捕捉（NumberFormatException e1）{
				// TODO 自动生成的 catch 块
				JOptionPane.showMessageDialog(this, "请正确输入信息！");
			}
		}

放弃“放弃”按钮功能

如果 (e.getX() >= 386 && e.getX() <= 496 && e.getY() >= 284
				&& e.getY() <= 316) {
			int result = JOptionPane.showConfirmDialog(this, "确认放弃？");
			如果（结果 == 0）{
				如果（黑色）{
					JOptionPane.showMessageDialog(this, "黑方认输，游戏结束！");
					可以播放=假；
				} 别的 {
					JOptionPane.showMessageDialog(this, "白方认输，游戏结束！");
					可以播放=假；
				}
				可以播放=假；
			}
		}

赋予“游戏说明”按钮功能

如果 (e.getX() >= 392 && e.getX() <= 493 && e.getY() >= 388
				&& e.getY() <= 427) {
			JOptionPane.showMessageDialog（这个，
					“这是一个五子棋游戏程序，黑白双方轮流下棋，一方接五，游戏结束。作者曾磊”）；
		}

判断输赢

私人布尔 checkWin() {
		布尔标志 = 假；
		// 保存连接了多少相同颜色的块
		整数计数 = 1；
		//判断水平方向是否有5个连接。特征纵坐标相同，即allChess[x][y]中的y值相同
		int color = allChess[x][y];
		//判断水平
		count = this.checkCount(1, 0, color);
		如果（计数> = 5）{
			标志=真；
		} 别的 {
			//判断垂直
			count = this.checkCount(0, 1, color);
			如果（计数> = 5）{
				标志=真；
			} 别的 {
				//判断右上和左下
				count = this.checkCount(1, -1, color);
				如果（计数> = 5）{
					标志=真；
				} 别的 {
					//判断右下角和左上角
					count = this.checkCount(1, 1, color);
					如果（计数> = 5）{
						标志=真；
					}
				}
			}
		}
		返回标志；
	}
	//判断连接的片数
	私人 int checkCount(int xChange, int yChange, int color) {
		整数计数 = 1；
		int tempX = xChange;
		int tempY = yChange;
		而 (x + xChange >= 0 && x + xChange <= 18 && y + yChange >= 0
				&& y + yChange <= 18
				&& 颜色 == allChess[x + xChange][y + yChange]) {
			计数++；
			如果 (xChange != 0)
				x改变++；
			如果（yChange！= 0）{
				如果 (yChange > 0)
					y改变++；
				别的 {
					y改变--;
				}
			}
		}
		xChange = tempX;
		yChange = tempY;
		而 (x - xChange >= 0 && x - xChange <= 18 && y - yChange >= 0
				&& y - yChange <= 18
				&& 颜色 == allChess[x - xChange][y - yChange]) {
			计数++；
			如果 (xChange != 0)
				x改变++；
			如果（yChange！= 0）{
				如果 (yChange > 0)
					y改变++；
				别的 {
					y改变--;
				}
			}
		}
		返回计数；
	}

检测时限

公共无效运行（）{
		// TODO 自动生成的方法存根
		//判断是否有时间限制
		如果（最大时间> 0）{
			而（真）{
				if (isBlack&&canPlay) {
					黑色时间——；
					如果（黑色时间 == 0）{
						JOptionPane.showMessageDialog(this, "黑方超时，游戏结束！");
					}
				} 否则 if(!isBlack&&canPlay) {
					白色时间——；
					如果（whiteTime == 0）{
						JOptionPane.showMessageDialog(this, "白方超时，游戏结束！");
					}
				}
				blackMessage = blackTime / 3600 + ":"
						+ (blackTime / 60 - blackTime / 3600 * 60) + ":"
						+ (blackTime - blackTime / 60 * 60);
				whiteMessage = whiteTime / 3600 + ":"
						+ (whiteTime / 60 - whiteTime / 3600 * 60) + ":"
						+ (whiteTime - whiteTime / 60 * 60);
				this.repaint();
				尝试 {
					线程.sleep(1000);
				} 捕捉（InterruptedException e）{
					// TODO 自动生成的 catch 块
					e.printStackTrace();
				}
				System.out.println(blackTime + " -- " + whiteTime);
			}
		}
	}