JavaSE021_数组之应用举例（利用二维数组实现五子棋图形版——二人对战）

最新推荐文章于 2022-01-04 09:59:39 发布
最新推荐文章于 2022-01-04 09:59:39 发布
阅读量2.1k 收藏 3
点赞数 1
分类专栏： From A Coder_JavaSE篇

转自：http://blog.csdn.net/cnlht/article/details/8176130

package com.cctvjiatao.FiveChess;

import java.awt.Color;
import java.awt.Cursor;
import java.awt.Dimension;
import java.awt.Graphics;
import java.awt.Graphics2D;
import java.awt.Image;
import java.awt.RadialGradientPaint;
import java.awt.RenderingHints;
import java.awt.Toolkit;
import java.awt.event.MouseEvent;
import java.awt.event.MouseListener;
import java.awt.event.MouseMotionListener;
import java.awt.geom.Ellipse2D;
import javax.swing.JOptionPane;
import javax.swing.JPanel;

/**
 * 五子棋--棋盘类
 * 
 * @author keletao
 * @date 2016-1-30 上午6:53:05
 */

public class ChessBoard extends JPanel implements MouseListener {
	public static final int MARGIN = 30;// 边距
	public static final int GRID_SPAN = 35;// 网格间距
	public static final int ROWS = 15;// 棋盘行数
	public static final int COLS = 15;// 棋盘列数

	Point[] chessList = new Point[(ROWS + 1) * (COLS + 1)];// 初始每个数组元素为null
	boolean isBlack = true;// 默认开始是黑棋先
	boolean gameOver = false;// 游戏是否结束
	int chessCount;// 当前棋盘棋子的个数
	int xIndex, yIndex;// 当前刚下棋子的索引

	Image img;
	Image shadows;
	Color colortemp;

	public ChessBoard() {
		// setBackground(Color.blue);//设置背景色为橘黄色
		img = Toolkit.getDefaultToolkit().getImage("board.jpg");
		shadows = Toolkit.getDefaultToolkit().getImage("shadows.jpg");
		addMouseListener(this);
		addMouseMotionListener(new MouseMotionListener() {
			public void mouseDragged(MouseEvent e) {

			}

			public void mouseMoved(MouseEvent e) {
				// 将鼠标点击的坐标位置转成网格索引
				int x1 = (e.getX() - MARGIN + GRID_SPAN / 2) / GRID_SPAN;
				int y1 = (e.getY() - MARGIN + GRID_SPAN / 2) / GRID_SPAN;
				// 游戏已经结束不能下
				// 落在棋盘外不能下
				// x，y位置已经有棋子存在，不能下
				if (x1 < 0 || x1 > ROWS || y1 < 0 || y1 > COLS || gameOver || findChess(x1, y1)){
					setCursor(new Cursor(Cursor.DEFAULT_CURSOR));// 设置成默认状态
				}else
					setCursor(new Cursor(Cursor.HAND_CURSOR));
			}
		});
	}

	// 绘制
	public void paintComponent(Graphics g) {
		super.paintComponent(g);// 画棋盘
		int imgWidth = img.getWidth(this);
		int imgHeight = img.getHeight(this);// 获得图片的宽度与高度
		int FWidth = getWidth();
		int FHeight = getHeight();// 获得窗口的宽度与高度
		int x = (FWidth - imgWidth) / 2;
		int y = (FHeight - imgHeight) / 2;
		g.drawImage(img, x, y, null);

		for (int i = 0; i <= ROWS; i++) {// 画横线
			g.drawLine(MARGIN, MARGIN + i * GRID_SPAN, MARGIN + COLS * GRID_SPAN, MARGIN + i * GRID_SPAN);
		}
		for (int i = 0; i <= COLS; i++) {// 画竖线
			g.drawLine(MARGIN + i * GRID_SPAN, MARGIN, MARGIN + i * GRID_SPAN, MARGIN + ROWS * GRID_SPAN);
		}

		// 画棋子
		for (int i = 0; i < chessCount; i++) {
			// 网格交叉点x，y坐标
			int xPos = chessList[i].getX() * GRID_SPAN + MARGIN;
			int yPos = chessList[i].getY() * GRID_SPAN + MARGIN;
			g.setColor(chessList[i].getColor());// 设置颜色
			colortemp = chessList[i].getColor();
			if (colortemp == Color.black) {
				RadialGradientPaint paint = new RadialGradientPaint(
						xPos - Point.DIAMETER / 2 + 25, 
						yPos - Point.DIAMETER / 2 + 10, 
						20, 
						new float[] { 0f, 1f }, 
						new Color[] { Color.WHITE, Color.BLACK });
				((Graphics2D) g).setPaint(paint);
				((Graphics2D) g).setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);
				((Graphics2D) g).setRenderingHint(RenderingHints.KEY_ALPHA_INTERPOLATION,RenderingHints.VALUE_ALPHA_INTERPOLATION_DEFAULT);
			} else if (colortemp == Color.white) {
				RadialGradientPaint paint = new RadialGradientPaint(
						xPos - Point.DIAMETER / 2 + 25, 
						yPos - Point.DIAMETER / 2 + 10, 
						70, 
						new float[] { 0f, 1f }, 
						new Color[] { Color.WHITE, Color.BLACK });
				((Graphics2D) g).setPaint(paint);
				((Graphics2D) g).setRenderingHint(RenderingHints.KEY_ANTIALIASING,RenderingHints.VALUE_ANTIALIAS_ON);
				((Graphics2D) g).setRenderingHint(RenderingHints.KEY_ALPHA_INTERPOLATION,RenderingHints.VALUE_ALPHA_INTERPOLATION_DEFAULT);
			}

			Ellipse2D e = new Ellipse2D.Float(xPos - Point.DIAMETER / 2, yPos - Point.DIAMETER / 2, 34, 35);
			((Graphics2D) g).fill(e); 
			// 标记最后一个棋子的红矩形框
			if (i == chessCount - 1) {// 如果是最后一个棋子
				g.setColor(Color.red);
				g.drawRect(xPos - Point.DIAMETER / 2, yPos - Point.DIAMETER / 2, 34, 35);
			}
		}
	}

	public void mousePressed(MouseEvent e) {// 鼠标在组件上按下时调用
		// 游戏结束时，不再能下
		if (gameOver){
			return;
		}
		String colorName = isBlack ? "黑棋" : "白棋";

		// 将鼠标点击的坐标位置转换成网格索引
		xIndex = (e.getX() - MARGIN + GRID_SPAN / 2) / GRID_SPAN;
		yIndex = (e.getY() - MARGIN + GRID_SPAN / 2) / GRID_SPAN;

		// 落在棋盘外不能下
		if (xIndex < 0 || xIndex > ROWS || yIndex < 0 || yIndex > COLS){
			return;
		}

		// 如果x，y位置已经有棋子存在，不能下
		if (findChess(xIndex, yIndex)){
			return;
		}

		// 可以进行时的处理
		Point ch = new Point(xIndex, yIndex, isBlack ? Color.black : Color.white);
		chessList[chessCount++] = ch;
		repaint();// 通知系统重新绘制

		// 如果胜出则给出提示信息，不能继续下棋
		if (isWin()) {
			String msg = String.format("恭喜，%s赢了！", colorName);
			JOptionPane.showMessageDialog(this, msg);
			gameOver = true;
		}
		isBlack = !isBlack;
	}

	// 覆盖mouseListener的方法
	public void mouseClicked(MouseEvent e) {
		// 鼠标按键在组件上单击时调用
	}

	public void mouseEntered(MouseEvent e) {
		// 鼠标进入到组件上时调用
	}

	public void mouseExited(MouseEvent e) {
		// 鼠标离开组件时调用
	}

	public void mouseReleased(MouseEvent e) {
		// 鼠标按钮在组件上释放时调用
	}

	// 在棋子数组中查找是否有索引为x，y的棋子存在
	private boolean findChess(int x, int y) {
		for (Point c : chessList) {
			if (c != null && c.getX() == x && c.getY() == y){
				return true;
			}
		}
		return false;
	}

	private boolean isWin() {
		int continueCount = 1;// 连续棋子的个数

		// 横向向西寻找
		for (int x = xIndex - 1; x >= 0; x--) {
			Color c = isBlack ? Color.black : Color.white;
			if (getChess(x, yIndex, c) != null) {
				continueCount++;
			}else{
				break;
			}
		}
		// 横向向东寻找
		for (int x = xIndex + 1; x <= COLS; x++) {
			Color c = isBlack ? Color.black : Color.white;
			if (getChess(x, yIndex, c) != null) {
				continueCount++;
			}else{
				break;
			}
		}
		if (continueCount >= 5) {
			return true;
		}else{
			continueCount = 1;
		}

		// 继续另一种搜索纵向
		// 向上搜索
		for (int y = yIndex - 1; y >= 0; y--) {
			Color c = isBlack ? Color.black : Color.white;
			if (getChess(xIndex, y, c) != null) {
				continueCount++;
			}else{
				break;
			}
		}
		// 纵向向下寻找
		for (int y = yIndex + 1; y <= ROWS; y++) {
			Color c = isBlack ? Color.black : Color.white;
			if (getChess(xIndex, y, c) != null){
				continueCount++;
			}else{
				break;
			}
		}
		if (continueCount >= 5){
			return true;
		}else{
			continueCount = 1;
		}
		// 继续另一种情况的搜索：斜向
		// 东北寻找
		for (int x = xIndex + 1, y = yIndex - 1; y >= 0 && x <= COLS; x++, y--) {
			Color c = isBlack ? Color.black : Color.white;
			if (getChess(x, y, c) != null) {
				continueCount++;
			}else{
				break;
			}
		}
		// 西南寻找
		for (int x = xIndex - 1, y = yIndex + 1; x >= 0 && y <= ROWS; x--, y++) {
			Color c = isBlack ? Color.black : Color.white;
			if (getChess(x, y, c) != null) {
				continueCount++;
			}else{
				break;
			}
		}
		if (continueCount >= 5){
			return true;
		}else{
			continueCount = 1;
		}
		// 继续另一种情况的搜索：斜向
		// 西北寻找
		for (int x = xIndex - 1, y = yIndex - 1; x >= 0 && y >= 0; x--, y--) {
			Color c = isBlack ? Color.black : Color.white;
			if (getChess(x, y, c) != null){
				continueCount++;
			}else{
				break;
			}
		}
		// 东南寻找
		for (int x = xIndex + 1, y = yIndex + 1; x <= COLS && y <= ROWS; x++, y++) {
			Color c = isBlack ? Color.black : Color.white;
			if (getChess(x, y, c) != null){
				continueCount++;
			}else{
				break;
			}
		}
		if (continueCount >= 5){
			return true;
		}else{
			continueCount = 1;
		}
		return false;
	}

	private Point getChess(int xIndex, int yIndex, Color color) {
		for (Point p : chessList) {
			if (p != null && p.getX() == xIndex && p.getY() == yIndex && p.getColor() == color)
				return p;
		}
		return null;
	}

	public void restartGame() {
		// 清除棋子
		for (int i = 0; i < chessList.length; i++) {
			chessList[i] = null;
		}
		// 恢复游戏相关的变量值
		isBlack = true;
		gameOver = false; // 游戏是否结束
		chessCount = 0; // 当前棋盘棋子个数
		repaint();
	}

	// 悔棋
	public void goback() {
		if (chessCount == 0){
			return;
		}
		chessList[chessCount - 1] = null;
		chessCount--;
		if (chessCount > 0) {
			xIndex = chessList[chessCount - 1].getX();
			yIndex = chessList[chessCount - 1].getY();
		}
		isBlack = !isBlack;
		repaint();
	}

	// 矩形Dimension
	public Dimension getPreferredSize() {
		return new Dimension(MARGIN * 2 + GRID_SPAN * COLS, MARGIN * 2 + GRID_SPAN * ROWS);
	}
}

package com.cctvjiatao.FiveChess;

import java.awt.Color;

/**
 * 棋子类
 * 
 * @author keletao
 * @date 2016-1-30 上午6:53:21
 */
public class Point {
	private int x;// 棋盘中的x索引
	private int y;// 棋盘中的y索引
	private Color color;// 颜色
	public static final int DIAMETER = 30;// 直径

	public Point(int x, int y, Color color) {
		this.x = x;
		this.y = y;
		this.color = color;
	}

	public int getX() {// 拿到棋盘中x的索引
		return x;
	}

	public int getY() {
		return y;
	}

	public Color getColor() {// 获得棋子的颜色
		return color;
	}
}


package com.cctvjiatao.FiveChess;

import java.awt.BorderLayout;
import java.awt.Container;
import java.awt.FlowLayout;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;

import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.JMenu;
import javax.swing.JMenuBar;
import javax.swing.JMenuItem;
import javax.swing.JPanel;

/**
 * 五子棋主框架类，程序启动类
 * 
 * @author keletao
 * @date 2016-1-30 上午6:53:38
 */
public class StartChessJFrame extends JFrame {
	private ChessBoard chessBoard;
	private JPanel toolbar;
	private JButton startButton, backButton, exitButton;

	private JMenuBar menuBar;
	private JMenu sysMenu;
	private JMenuItem startMenuItem, exitMenuItem, backMenuItem;

	// 重新开始，退出，和悔棋菜单项
	public StartChessJFrame() {
		setTitle("单机版五子棋");// 设置标题
		chessBoard = new ChessBoard();

		Container contentPane = getContentPane();
		contentPane.add(chessBoard);
		chessBoard.setOpaque(true);

		// 创建和添加菜单
		menuBar = new JMenuBar();// 初始化菜单栏
		sysMenu = new JMenu("系统");// 初始化菜单
		// 初始化菜单项
		startMenuItem = new JMenuItem("重新开始");
		exitMenuItem = new JMenuItem("退出");
		backMenuItem = new JMenuItem("悔棋");
		// 将三个菜单项添加到菜单上
		sysMenu.add(startMenuItem);
		sysMenu.add(exitMenuItem);
		sysMenu.add(backMenuItem);
		// 初始化按钮事件监听器内部类
		MyItemListener lis = new MyItemListener();
		// 将三个菜单注册到事件监听器上
		this.startMenuItem.addActionListener(lis);
		backMenuItem.addActionListener(lis);
		exitMenuItem.addActionListener(lis);
		menuBar.add(sysMenu);// 将系统菜单添加到菜单栏上
		setJMenuBar(menuBar);// 将menuBar设置为菜单栏

		toolbar = new JPanel();// 工具面板实例化
		// 三个按钮初始化
		startButton = new JButton("重新开始");
		exitButton = new JButton("退出");
		backButton = new JButton("悔棋");
		// 将工具面板按钮用FlowLayout布局
		toolbar.setLayout(new FlowLayout(FlowLayout.LEFT));
		// 将三个按钮添加到工具面板
		toolbar.add(startButton);
		toolbar.add(exitButton);
		toolbar.add(backButton);
		// 将三个按钮注册监听事件
		startButton.addActionListener(lis);
		exitButton.addActionListener(lis);
		backButton.addActionListener(lis);
		// 将工具面板布局到界面”南方“也就是下方
		add(toolbar, BorderLayout.SOUTH);
		add(chessBoard);// 将面板对象添加到窗体上
		// 设置界面关闭事件
		setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
		// setSize(800,800);
		pack();// 自适应大小
	}

	private class MyItemListener implements ActionListener {
		public void actionPerformed(ActionEvent e) {
			Object obj = e.getSource();// 获得事件源
			if (obj == StartChessJFrame.this.startMenuItem || obj == startButton) {
				// 重新开始
				// JFiveFrame.this内部类引用外部类
				System.out.println("重新开始");
				chessBoard.restartGame();
			} else if (obj == exitMenuItem || obj == exitButton)
				System.exit(0);
			else if (obj == backMenuItem || obj == backButton) {
				System.out.println("悔棋...");
				chessBoard.goback();
			}
		}
	}

	public static void main(String[] args) {
		StartChessJFrame f = new StartChessJFrame();// 创建主框架
		f.setVisible(true);// 显示主框架
	}
}

【运行结果】：


可乐淘
关注
专栏目录
【JavaSE】多图解，保姆级详细讲解数组、二维数组--建议收藏
Yaoyao2024的博客
01-17 2576
保姆级讲解Java中的数组（一维、二维）。用图解，代码，让你最大可能的去了解和熟悉Java中的数组以及其在内存中的情况。详细讲解如何去使用数组！
java五子棋的实现，实现人人对战，人机对战
06-03
java五子棋的实现，适合学生的课程设计，希望能够帮到大家，实现人机对战，和人人对战功能模式，有时间统计
二维数组实现五子棋小游戏
08-08
用java的二维数组实现五子棋小游戏，适合初学者学习二维数组
JavaSE017_数组之应用举例（利用二维数组实现五子棋功能完善——二人对战）
可乐淘的专栏
01-26 1125
import java.io.BufferedReader; import java.io.InputStreamReader; import java.util.Arrays; public class FiveChess { private static final int CELL = 16; private static final char CELL_CHAR = '┼'; p
二维数组做五子棋java_用二维数组来完成五子棋游戏
weixin_32058931的博客
02-27 434
1、Gobang.javapackage xuexi;import java.io.BufferedReader;import java.io.InputStreamReader;import java.util.Scanner;public class Gobang {//定义棋盘大小private static int BOARD_SIZE=15;//定义一个二维数组来充当棋盘private ...
Java版-五子棋（二维数组）
幸运如你的博客
08-09 1660
import java.util.Scanner; public class Gobang { public static int length = 15; public static String[][] chessBoard = new String[length][length]; public static void main(String[] args) { ...
JavaSE015_数组之应用举例（利用二维数组实现五子棋初步功能）
可乐淘的专栏
01-23 643
import java.io.*; public class Gobang { //定义一个二维数组来充当棋盘 private String[][] board; //定义棋盘的大小 private static int BOARD_SIZE = 15; public void initBoard() { //初始化棋盘数组 board = new String[BOARD_
JavaSE__数组及常用算法.ppt
03-19
JavaSE__数组及常用算法.ppt
(5)javaSE_数组.xmind
08-21
主要是关于数组的xmind思维导图梳理的图解，更好的理解数组的应用
JavaSE之数组与集合类
07-21
JavaSE是Java标准版的简称，它是Java编程的基础，涵盖了面向对象编程的核心概念和技术。在这个话题中，我们将探讨Java中的数组和集合类，这些都是JavaSE阶段的重要知识点。 首先，让我们从面向对象编程说起。面向...
05_javase复习总结之数组
04-23
### 05_javase复习总结之数组 #### 数组定义和基本用法 在Java中，数组是一种基本的数据结构，用于存储固定大小的同类型元素集合。它提供了高效的访问和管理这些元素的方式。 ##### 数组声明与初始化 1. **声明...
java五子棋（数组实现）
03-13
java数组实现五子棋源代码原创，手动输入坐标
14 数组
qq_53537301的博客
03-21 931
数组 数组的定义 数组是相同类型数据的有序集合 数组描述的是相同类型的若干个数据,按照一定的先后次序排列组合而成 其中,每一个数据称作一个数组元素每个数组元素可以通过一个下标来访问它们 数组声明创建 首先必须声明数组变量，才能在程序中使用数组。下面是声明数组变量的语法: dataType[] arrayRefVar; // 首选的方法 或 dataType arrayRefVar[]; // 效果相同，但不是首选方法 Java语言使用new操作符来创建数组，语法如下: dataType[] array
新手学java-运用数组写一个五子棋小程序
imxintian 的博客
11-26 2535
package GoBang;import java.io.BufferedReader; import java.io.IOException; import java.io.InputStreamReader;public class GoBang { //定义棋盘大小 private static int BOARD_SIZE=15; //定义一个二维数组来充当棋盘
简单的五子棋小游戏（java 二维数组，在控制台做的）
iamsostrongwhy的博客
08-04 1000
@ 一个简单的五子棋盘(二维数组) 棋盘的大小定义 首先得定义一个二维的数组int[][] chessboard = new int [i][j] 其中 i的值代表一个棋盘的纵数， y代表横数， 五子棋盘应该是19*19没记错的话，所以可以将括号内的i,j改成19，19 先给棋盘的每一行每一列都加上序号，方便查阅， 比如 1 2 3 4 5 6 ​ 1 + + + + + + ​ ...
java Arrays数组
weixin_34015860的博客
12-06 80
  二、java数据类型之Arrays（数组） 迁移时间--2017年12月6日10:51:07 Author:Marydon 　　需要导入的包： import java.util.Arrays; UpdateTime--2017年3月31日17:49:53  （一）数据格式 [aa, bb, cc] （二）初始化 // 方法一 String[] st...
javas数组
m0_56173583的博客
01-04 333
1.数组反转 2.获取最大数 3.排序 数组分为一维数组，二维数组和多维数组 一维数组 数组的初始化 数组的初始化分为动态初始化和静态初始化 动态初始化 声明并开辟数组 数据类型[] 数组名=new 数据类型[数组长度] 数组长度：代表你可以向数组存储多少个数据 数组的下标是从零开始到数组长度-1，当超出数组的索引长度则会产生java.lang.ArrayIndexOutOfBoundsException异常信息 数组名.length:获取数组长度
java 实现双人五子棋
a736225348的博客
08-02 1608
通过上下左右控制棋盘走动 空格落子 (深度优先搜索) package day_1; import java.awt.*; import javax.swing.*; import java.awt.event.*; public class CircleRun extends JFrame { /** * */ MyPanel mp = null; p...
Java数组
s_crawler的博客
07-31 101
JavaSE进阶：数组深度解析与应用
"动力节点的JavaSE进阶课程涵盖了数组的深入学习，包括一维和二维数组的声明、使用、排序和查找，以及Arrays工具类的应用。" 在Java编程语言中，数组是一个重要的概念，它是一种引用数据类型，允许在内存中存储一组...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值