0
0

Java实现五子棋对战小游戏【完整版】

007aec030ace45f49140c114e299a499.png

** 个人简介**

👨🏻‍💻个人主页：陈橘又青

🏃🏻‍♂️博客记录心情，代码编写人生。

🌟如果文章对你有用，麻烦关注点赞收藏走一波，感谢支持！

🌱欢迎订阅我的专栏：

✍️【Java进阶之路】带你入门Java，从0到1。

🤳🏻【Java全栈编程】带你项目实战，掌握核心。

前言

大家好，今天用swing技术写一个单机版的五子棋对战小游戏，文中示例思路清晰、代码完整，适合Java初学者尝试实战，供大家参考。

效果展示

d9f65d51c0f64e76ac455419c83a92e3.png

目录

效果展示

一、游戏界面

0c8ef08d320c4128954c66b729d7da12.png

二、悔棋与重开功能

569065c5f28d41e68e8ea52706f21f2b.png

项目介绍

五子棋是一种两人对弈的纯策略型棋类游戏，亦称串珠连，五子是中国民间非常熟知的一个古老棋种，它因操作简单、逻辑性强，深受喜爱，本项目基于Java技术，开发了一个操作简单、界面简洁、功能较完整的“五子棋”游戏。通过本游戏的开发，达到初学者学习和熟悉软件开发流程的目的。

总体需求

本程序主要完成五子棋游戏的简单操作，用户通过鼠标完成游戏过程。需要满足以下几点要求：

1．实现五子棋简易窗口界面。
2．实现黑白棋轮流下棋功能。
3．实现自动判断获胜方功能。
4．实现悔棋与重开游戏功能。

实现过程

1.绘制窗体对象。

2.UI设计（包括游戏区域、黑白棋子、按钮和标题区域）。

3.使用鼠标监听事件实现下棋。

4.连成五子判定获胜的实现。

代码展示

主框架

在主框架里有面板对象和两个按钮对象，分别是重新开始游戏按钮，悔棋按钮。还设置一个按钮事件类，用来监听两个按钮，并作出相应的动作，代码如下：

  1. import java.awt.*;
  2. import java.awt.event.ActionEvent;
  3. import java.awt.event.ActionListener;
  4. import javax.swing.*;
  5. public class ChessJFrame extends JFrame {
  6.     private ChessBord chessbord;//声明一个棋盘对象
  7.     private Panel tool;            //声明一个面板对象
  8.     private Button StartButton;//声明开始按钮
  9.     private Button BackButton;//声明悔棋按钮
  10.     private Button exitButton;//声明退出按钮
  11.     public ChessJFrame() {//构造函数
  12.         setTitle("单机版五子棋");//设置标题
  13.         MyButtonLister mb=new MyButtonLister();//按钮事件处理对象
  14.         tool=new Panel();//面板对象
  15.         chessbord=new ChessBord();//棋盘对象
  16.         StartButton=new Button("Reopen");//设置开始按钮
  17.         BackButton=new Button("Regret");//设置悔棋按钮
  18.         //exitButton=new Button("EXIT");//设置退出游戏按钮
  19.         tool.setLayout(new FlowLayout(FlowLayout.CENTER ));//流式布局
  20.         tool.add(StartButton);
  21.         tool.add(BackButton);
  22.        // tool.add(exitButton);//将三个按钮添加到面板对象
  23.         StartButton.addActionListener(mb);
  24.         BackButton.addActionListener(mb);
  25.        // exitButton.addActionListener(mb);//将三个按钮添加到事件监听
  26.         add(tool,BorderLayout.SOUTH);//按钮所在的位置
  27.         add(chessbord);//添加棋盘对象
  28.         setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);//设置关闭
  29.         pack();//自适应
  30.     }
  31.     private class MyButtonLister implements ActionListener{
  32.         //按钮处理事件类
  33.         @Override
  34.         public void actionPerformed(ActionEvent e) {
  35.             // TODO Auto-generated method stub
  36.             Object obj=e.getSource();//获取事件源
  37.             if(obj==StartButton) {//事件源是重新开始按钮
  38.                 System.out.println("重新开始");
  39.                 chessbord.restartGame();
  40.             }
  41.             else if(obj==BackButton) {//事件源是悔棋按钮
  42.                 System.out.println("悔棋！");
  43.                 chessbord.goback();
  44.             }
  45.             else if(obj==exitButton) {//事件源是退出按钮
  46.                 System.exit(0);
  47.             }
  48.         }
  49.     }
  50.     public static void main(String[] args) {
  51.         ChessJFrame jf=new ChessJFrame();//声明框架对象
  52.         jf.setLocationRelativeTo(null);//居中显示
  53.         jf.setVisible(true);//设置为可见
  54.     }
  55. }

棋子类

棋子类里有棋子的坐标，半径和颜色；还有棋子的构造函数。代码如下：

  1. import java.awt.Color;
  2. public class Chess {
  3.     private int x;//棋子的x坐标索引
  4.     private int y;//棋子的y坐标索引
  5.     private Color color;//棋子颜色
  6.     public static   int DIAMETER=30;//直径
  7.     public Chess(int x,int y,Color color){//棋子构造函数
  8.         this.x=x;
  9.         this.y=y;
  10.         this.color=color;
  11.     }
  12.     public int getX() {
  13.         return x;
  14.     }
  15.     public int getY() {
  16.         return y;
  17.     }
  18.     public Color getColor() {
  19.         return color;
  20.     }
  21.     
  22. }

棋盘类

我们要对棋盘的边距，网格的距离进行赋值，设定棋盘的初始状态，如默认黑子先下，定义一个棋子类数组，来保存棋子对象，再定义一个字符串二维数组函数来保存颜色，用来判断输赢，用匿名内部类来处理当棋子在面板上移动时的一些状态。

再对下棋时鼠标按下时的动作事件类进行解析，当在网格上下棋时，判断是否在棋盘内和判断网格上有没有棋子，当棋子在棋盘内并且网格上没有棋子，我们就开始画棋子，将棋子对象和颜色保存，接下来判断是否胜利，判断棋盘是否下满，如果没有继续下棋。

使用函数paintComponent来对棋盘和棋子进行画图，对棋子进行绘图时，将最后一个棋子设为红色。

最后就是判断棋子输赢的函数win，用字符串数组保存的棋子的颜色来进行判断所在行和列有没有五个棋子相连，判断撇和捺行的棋子有没有五个相连的，如果有则某位棋子胜利。代码如下：

  1. import java.awt.*;
  2. import java.awt.event.*;
  3. import javax.swing.*;
  5. public class ChessBord extends JPanel implements MouseListener{//继承面板类和鼠标事件接口
  6.     public static int MARGIN=30;//定义边距
  7.     public static int ROWS=15;//定义行数
  8.     public static int COLS=15;//定义列数
  9.     public static int GRID_SPAN=35;//网格间距
  10.     Chess[] chessList=new Chess[(ROWS+1)*(COLS+1)];//定义一个棋子数组
  11.     String[][] board=new String[MARGIN*2+GRID_SPAN*COLS][MARGIN*2+GRID_SPAN*COLS];//声明一个字符串数组，用来判断输赢
  12.     int chessCount;//棋子数目
  13.     int xindex,yindex;//棋子的坐标索引
  14.     boolean start=true;//开始默认黑子先下
  15.     boolean GameOver=false;//定义是否游戏结束
  16.     public ChessBord() {//棋盘类构造函数
  17.         setBackground(Color.LIGHT_GRAY);//设置背景颜色
  18.         addMouseListener(this);//将棋盘类添加到鼠标事件监听器
  19.         addMouseMotionListener(new MouseMotionListener() {//匿名内部类
  20.             @Override
  21.             public void mouseMoved(MouseEvent e) {//根据鼠标的移动所在的坐标来设置鼠标光标形状
  22.                 int x1=(e.getX()-MARGIN+GRID_SPAN/2)/GRID_SPAN;//对鼠标光标的x坐标进行转换
  23.                 int y1=(e.getY()-MARGIN+GRID_SPAN/2)/GRID_SPAN;//对鼠标光标的y坐标进行转换
  24.                 if(x1<0||x1>ROWS||y1<0||y1>COLS||GameOver||findchess(x1, y1)) {
  25.                     setCursor(new Cursor(Cursor.DEFAULT_CURSOR));//设置鼠标光标为默认形状
  26.                 }else {
  27.                     setCursor(new Cursor(Cursor.HAND_CURSOR));//设置鼠标光标为手型
  28.                 }
  29.             }
  30.             @Override
  31.             public void mouseDragged(MouseEvent e) {
  32.             }
  33.         });
  34.         for(int i=0;i<MARGIN*2+GRID_SPAN*COLS;i++) {//对board[][]赋初值
  35.             for (int j = 0; j < MARGIN*2+GRID_SPAN*COLS; j++) {
  36.                 board[i][j]="0";
  37.             }
  38.         }
  39.     }
  40.     @Override
  41.     public void mouseClicked(MouseEvent e) {
  42.         // TODO Auto-generated method stub
  43.     }
  44.     @Override
  45.     public void mousePressed(MouseEvent e) {//鼠标点击事件
  46.         if(GameOver)//游戏结束，不能按
  47.             return ;
  48.         String colorName=start?"黑棋":"白棋";//判断是什么颜色的棋子
  49.         xindex=(e.getX()-MARGIN+GRID_SPAN/2)/GRID_SPAN;//得到棋子x坐标
  50.         yindex=(e.getY()-MARGIN+GRID_SPAN/2)/GRID_SPAN;//得到棋子y坐标
  51.         board[xindex][yindex]=colorName;//以棋子x坐标y坐标做索引将棋子的颜色添加到board中
  52.         if(xindex<0||xindex>ROWS||yindex<0||yindex>COLS) {//棋子在棋盘外不能下，
  53.             return ;
  54.         }else if(findchess( xindex, yindex)) {//所下位置已有棋子，不能下
  55.             return ;
  56.         }
  57.         Chess po=new Chess(xindex,yindex,start?Color.black:Color.WHITE);//对棋子对象进行初始化
  58.         chessList[chessCount++]=po;//将棋子对象添加到棋子数组中
  59.         repaint();//重画图型
  60.         if(win( xindex,yindex,start)) {//判断是否胜利
  61.             String msg=String.format("恭喜 %s赢了",colorName);
  62.             JOptionPane.showMessageDialog(this, msg);
  63.             //gameOver=true;
  64.             GameOver=true;
  65.         }else if(chessCount==(COLS+1)*(ROWS+1)) {//判断是否全部下满
  66.             String msg=String.format("恭喜 %s赢了",colorName);
  67.             JOptionPane.showMessageDialog(this, msg);
  68.             GameOver=true;
  69.         }
  70.         start=!start;//改变棋子先下棋状态
  71.     }
  72.     @Override
  73.     public void mouseReleased(MouseEvent e) {
  74.     }
  75.     @Override
  76.     public void mouseEntered(MouseEvent e) {
  77.     }
  78.     @Override
  79.     public void mouseExited(MouseEvent e) {
  80.     }
  81.     @Override
  82.     protected void paintComponent(Graphics g) {//画棋盘和棋子
  83.         super.paintComponent(g);
  84.         for(int i=0;i<=ROWS;i++) {//画横线
  85.             g.drawLine(MARGIN, MARGIN+i*GRID_SPAN, MARGIN+COLS*GRID_SPAN, MARGIN+i*GRID_SPAN);
  86.         }
  87.         for(int j=0;j<=COLS;j++) {//画竖线
  88.             g.drawLine(MARGIN+j*GRID_SPAN, MARGIN, MARGIN+j*GRID_SPAN, MARGIN+ROWS*GRID_SPAN);
  89.         }
  90.         for(int i=0;i<chessCount;i++) {//画棋子
  91.             int xpos=chessList[i].getX()*GRID_SPAN+MARGIN;//得到棋子x坐标
  92.             int ypos=chessList[i].getY()*GRID_SPAN+MARGIN;//得到棋子y坐标
  93.             g.setColor(chessList[i].getColor());//设置棋子颜色
  94.             g.fillOval(xpos-Chess.DIAMETER/2, ypos-Chess.DIAMETER/2, Chess.DIAMETER, Chess.DIAMETER);//画棋子
  95.             if(i==chessCount-1){
  96.                 g.setColor(Color.red);//标记最后一个棋子为红色
  97.                 g.drawRect(xpos-Chess.DIAMETER/2, ypos-Chess.DIAMETER/2, Chess.DIAMETER, Chess.DIAMETER);
  98.             }
  99.         }
  100.     }
  101.     private    boolean findchess(int index,int yindex) {//查找所在位置是否有棋子
  102.         for (Chess c : chessList) {
  103.             if(c!=null&&c.getX()==xindex&&c.getY()==yindex)
  104.                 return true;
  105.         }
  106.         return false;
  107.     }
  108.     private    boolean win(int x,int y,boolean start) {//对棋子输赢的判断
  109.         String str=start?"黑棋":"白棋";
  110.         //棋子所在行和列是否有五子相连的情况
  111.         for(int i=0;i<16;i++){
  112.             if((board[x][i].equals(str)&&board[x][i+1].equals(str)&&board[x][i+2].equals(str)&&board[x][i+3].equals(str)&&board[x][i+4].equals(str))||(board[i][y].equals(str)&&board[i+1][y].equals(str)&&board[i+2][y].equals(str)&&board[i+3][y].equals(str)&&board[i+4][y].equals(str)))
  113.                 return true;
  114.         }
  115.         //棋子所在撇行是否有五子相连的情况
  116.         if(x+y>=4&&x+y<=30){
  117.             int i=(x+y<=19)?x+y:x+y-20;
  118.             if(x+y<=19){
  119.                 for(int k=0;k<=i-4;k++){
  120.                     if(board[k][i-k].equals(str)&&board[k+1][i-k-1].equals(str)&&board[k+2][i-k-2].equals(str)&&board[k+3][i-k-3].equals(str)&&board[k+4][i-k-4].equals(str))
  121.                         return true;
  122.                 }
  123.             }else{
  124.                 for(int k=i;k<=15;k++){
  125.                     if(board[k][20-k].equals(str)&&board[k+1][20-k-1].equals(str)&&board[k+2][20-k-2].equals(str)&&board[k+3][20-k-3].equals(str)&&board[k+4][20-k-4].equals(str))
  126.                         return true;
  127.                 }
  128.             }
  129.         }
  130.         //棋子所在捺行是否有五子相连的情况
  131.         if(y-x<=15&&x-y<=15){
  132.             int i=(x<y)?y-x:x-y;
  133.             if(x<y){
  134.                 for(int k=0;k<=19-4-i;k++){
  135.                     if(board[k][i+k].equals(str)&&board[k+1][i+k+1].equals(str)&&board[k+2][i+k+2].equals(str)&&board[k+3][i+k+3].equals(str)&&board[k+4][i+k+4].equals(str))
  136.                         return true;
  137.                 }
  138.             }else{
  139.                 for(int k=i;k<=15;k++){
  140.                     if(board[k][i+k].equals(str)&&board[k+1][i+k+1].equals(str)&&board[k+2][i+k+2].equals(str)&&board[k+3][i+k+3].equals(str)&&board[k+4][i+k+4].equals(str))
  141.                         return true;
  142.                 }
  143.             }
  144.         }
  145.         return false;
  146.     }
  147.     public void goback() {//悔棋函数
  148.         if(chessCount==0) {
  149.             return ;
  150.         }
  151.         chessList[chessCount-1]=null;
  152.         chessCount--;
  153.         if(chessCount>0) {
  154.             xindex=chessList[chessCount-1].getX();
  155.             yindex=chessList[chessCount-1].getY();
  156.         }
  157.         start=!start;
  158.         repaint();
  159.     }
  160.     public void restartGame() {//重新开始函数
  161.         for(int i=0;i<chessList.length;i++)//设置为初始状态
  162.             chessList[i]=null;
  163.         for(int i=0;i<MARGIN*2+GRID_SPAN*COLS;i++) {
  164.             for (int j = 0; j < MARGIN*2+GRID_SPAN*COLS; j++) {
  165.                 board[i][j]="0";
  166.             }
  167.         }
  168.         start=true;
  169.         GameOver=false;
  170.         chessCount=0;
  171.         repaint();
  172.     }
  173.     public Dimension getPreferredSize(){//画矩形
  174.         return new Dimension(MARGIN*2+GRID_SPAN*COLS,MARGIN*2+GRID_SPAN*ROWS);
  175.     }
  177. }

项目结构

833ca990f566430c8c7befe6f2820d23.png

本程序用于Java初学者学习，共封装三个类，分别是主框架ChessJFrame类、棋子Chess类、棋盘ChessBord类，结构简单，框架明了。

总结

本项目的设计思路与“五子棋”游戏一致，程序在界面设计与功能实现上还有许多不足，但该项目的实现对于Java编程新手实战能力的提升有很大作用，在编写该项目的过程中，对编程者算法的设计能力与面向对象编程的理解都有深刻的考验。

程序在一定程序上还有还有缺陷，仅用于初学者学习，欢迎各位指正。

25670c4248b241059da027dd536d72da.png

标签： java 开发语言
本文转载自: https://blog.csdn.net/m0_63947499/article/details/125417438
版权归原作者 青00 （一起学Java） 所有， 如有侵权，请联系我们删除。
登录后发布评论

“Java实现五子棋对战小游戏【完整版】”的评论:

还没有评论
关于作者
...
overfit同步小助手
文章同步
相关阅读

网络安全法-网络运行安全

使用selenium/drissionpage时如何阻止chrome自动跳转http到https

docker desktop 里部署的Open WebUI 管理员密码忘记了的处理方法

在ubuntu20.04中搭建onsite比赛运行环境

利用开源的低代码表单设计器FcDesigner高效管理和渲染复杂表单结构

Kafka学习笔记

【前端】浏览器输入url到页面呈现发生了什么？