用Java写一个简易五子棋游戏

最新推荐文章于 2025-07-28 09:20:38 发布
最新推荐文章于 2025-07-28 09:20:38 发布
阅读量917 收藏 21
点赞数 36
CC 4.0 BY-SA版权
文章标签： 游戏 java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zjr060330/article/details/148031288

        今天我们来用Java写一个简易的五子棋游戏。

1.UI设计

        首先，我们需要一个显示游戏的UI界面。创建GameUI类，给界面设置合适的标题、大小等属性。设置窗体可见并添加画笔。如此便搭好了UI的整体框架。

public void initUI() {
        Mframe jf = new Mframe();//此处Mframe为继承Jframe的子定义子类，后文会详细解释。
        jf.setSize(1000, 1000);
        jf.setTitle("五子棋游戏");
        jf.setLocationRelativeTo(null);
        jf.setDefaultCloseOperation(3);
        
        jf.setVisible(true);

        Graphics g = jf.getGraphics();
}

        接下来选取合适的间距画线（注意适当留白），生成一个五子棋棋盘。为了方便之后的功能添加，我们可在空白处设置按钮面板并添加相应的按钮。这里添加了三个功能按钮，分别为“开始”“悔棋”“复盘”。

//设置面板
        JPanel esatPanel = new JPanel();
        esatPanel.setPreferredSize(new Dimension(80, 0));
        jf.add(esatPanel, BorderLayout.EAST);
//添加功能按钮和动作监听器（后文详解）
        GameListener listener = new GameListener();
        String[] name = {"开始", "悔棋", "复盘"};
        for (int i = 0; i < name.length; i++) {
            JButton jbu = new JButton(name[i]);
            esatPanel.add(jbu);
            jbu.addActionListener(listener);
        }

//棋盘绘制
for (int i = 0; i < 9; i++) {
            g.drawLine(100, 100 + i * 100, 900, 100 + i * 100);
            g.drawLine(100 + i * 100, 100, 100 + i * 100, 900);
        }

        添加主函数，创建GameUI的对象并调用initUI方法，便能看到简易的五子棋界面。

2.棋子绘制

        有棋盘之后，我们需要实现下棋功能，即棋子绘制。棋子绘制本质便是在鼠标点击后在相应位置画实心圆和空心圆（画实心圆的方法为fillOval，画空心圆的方法为drawOval，它们都需要四个参数，x y对应外接矩形的左上角坐标，width和height对应外接矩形宽高，设置宽高相等即可得到圆）。因此，我们首先要给窗体加上鼠标监听器来识别点击的位置。但是棋子的中心应该正好落于棋盘线的交点处，所以我们需要对获取的点击坐标进行一定数学运算处理，并设置一个标志位flag来判断应该下黑棋还是白棋。

public void mouseClicked(MouseEvent e) {
//定义x y存储点击的坐标值
        int x = e.getX();
        int y = e.getY();

//对x y进行处理使坐标能落在棋盘线交点
        if (x % 100 <= 50) {
            x1 = x - x % 100;
        }
        else {
            x1 = x + 100 - x % 100;
        }
        if (y % 100 <= 50) {
            y1 = y - y % 100;
        }
        else {
            y1 = y + 100 - y % 100;
        }
//边缘情况处理        
        if (x > 900) x1 = 900;
        if (x < 100) x1 = 100;
        if (y > 900) y1 = 900;
        if (y < 100) y1 = 100;
 
//提前创建整形二维数组Chess[][]用于记录棋子位置，黑棋置一，白棋置二
        if (Chess[y1 / 100 - 1][x1 / 100 - 1] != 0) {
            System.out.println("该位置已有棋子！");
            return;
        }
        if (flag % 2 == 0) {
            g.fillOval(x1 - 25, y1 - 25, 50, 50);
            Chess[y1 / 100 - 1][x1 / 100 - 1] = 1;
        } else {
            g.drawOval(x1 - 25, y1 - 25, 50, 50);
            Chess[y1 / 100 - 1][x1 / 100 - 1] = 2;
        }

3.输赢判断

        实现下棋功能后，我们来进一步实现输赢判断。当有一方在横竖左右任一方向下出五个连续棋子时，此人获胜。在代码层面，若是每次都遍历二维数组判断连续棋子数则过于麻烦，所以我们选择计算最后落下的棋子各方向的连续同色棋子数。计算时需要注意坐标和对应数组位置的转换和数组越界问题。此处以计算横向棋子数的方法Iswin1为例。

 public int Iswin1(int x1, int y1) {
        int c = 1;//用c记录棋子数量，初始值为1，即棋子本身
        int a = Chess[y1 / 100 - 1][x1 / 100 - 1];//进行坐标转换并用a的值代表黑白
        for (int i = y1 / 100 - 2; i >= 0 && i >= y1 / 100 - 5; i--) {

            if (Chess[i][x1 / 100 - 1] == a) {
                c++;

            } else break;
        }

        for (int i = y1 / 100; i <= 8 && i <= y1 / 100 + 4; i++) {
            if (Chess[i][x1 / 100 - 1] == a) {
                c++;
            } else break;
        }

        return c;//返回棋子数量
    }

        当Iswin1到Iswin4任一值为5时，即可通过flag的奇偶判断胜负。此时我们定义变量flag1，当它由0变为1时表示胜负已分，游戏结束，再点击棋盘将显示“游戏已结束！”。

4.图形重绘

        在实现游戏基本功能之后，我们应添加图形重绘功能，使窗体状态改变后仍能保留棋盘棋子。定义Shape类以保存棋子数据和画棋方法。

public class Shape {
    public int x1,y1,flag;
//保存棋子数据    
    public Shape(int x1,int y1,int flag){
        this.x1 = x1;
        this.y1 = y1;
        this.flag = flag;
    }
//画棋方法
    public void drawShape(Graphics g){
        if (flag % 2 == 0) {
            g.fillOval(x1 - 25, y1 - 25, 50, 50);

        } else {
            g.drawOval(x1 - 25, y1 - 25, 50, 50);
        }
    }
}

​

        为了实现重绘，我们需用MPanel类去继承JPanel类，重写paint方法，在保留父类功能的基础上加入画棋子棋盘的功能。

public class Mframe extends JFrame {
    public Shape[] shapeArr;

    public void paint(Graphics g) {
        super.paint(g);//保留父类功能
//画棋盘
        for (int i = 0; i < 9; i++) {
            g.drawLine(100, 100 + i * 100, 900, 100 + i * 100);
            g.drawLine(100 + i * 100, 100, 100 + i * 100, 900);
        }
//画棋子
        for (int i = 0; i < shapeArr.length; i++) {
            Shape shape = shapeArr[i];
            if (shape == null) break;
            shape.drawShape(g);
        }
    }
}

        接着我们在Gamelistener类中创建Shape类的数组shapeArr存储棋子数据，并把数据传递给GameUI类。窗体状态改变时即会自动执行重绘功能。

5.功能添加

        在此基础上，我还添加了“开始”“悔棋”“复盘”三种功能。

1.开始

        点击“开始”之后，才可以开始下棋，而且此按钮带有清空棋盘的功能，即重新开始游戏。我们设置boolean型变量start，初始值为false，这时点击棋盘将显示“请点击开始！”。点击“开始”后，start置为true，数组Chess和shapeArr以及标志位全部置零，方可开始游戏。

2.悔棋

        “悔棋”的功能是撤销上一个棋子，并可以做到连续撤销。此过程需要将Chess和shapeArr相应位置的数据清空并让索引下标减一，之后进行一次图形重绘，就能达到清除上一步棋子的效果。

3.复盘

        “复盘”的功能是从头再现下棋的过程。实现复盘的第一步是清空棋盘。我们可以令设置shapeArr1数组保存和shapeArr相同的图形数据。在复盘时，我们先将shapeArr清空执行重绘，再遍历shapeArr1一个个画出棋子。为了防止画棋子的速度过快，我们需要设计合理的睡眠时间使下两颗棋有一定的间隔。

public void actionPerformed(ActionEvent e) {
        String str = e.getActionCommand();
        switch (str) {
            case "开始":
                flag1 = 0;
                start = true;
                for (int i = 0; i < 9; i++) {
                    for (int j = 0; j < 9; j++) {
                        Chess[i][j] = 0;
                    }
                }
                for (int i = 0; i < flag; i++) {
                    shapeArr[i] = null;
                }
                flag = 0;
                mf.paint(g);
                break;
            case "悔棋":
                if (flag >= 1) {
                    shapeArr[flag - 1] = null;
                    Chess[Y[--Index] / 100 - 1][X[--Index] / 100 - 1] = 0;
                    index1--;
                    flag--;
                }
                mf.paint(g);
                break;
            case "复盘":
                for (int i = 0; i < shapeArr.length; i++) {
                    shapeArr[i] = null;
                }
                mf.paint(g);
                for (int i = 0; i < shapeArr0.length; i++) {
                    Shape shape = shapeArr0[i];
                    if (shape == null) break;
                    try {
                        Thread.currentThread().sleep(1000);
                    } catch (InterruptedException ie) {
                        ie.printStackTrace();
                    }
                    shape.drawShape(g);
                }
                break;
        }

    }

  6.GameUI与GameListener完整代码

          以下是经过功能添加与细化后的GameUI类与GameListener类的完整代码。

public class GameUI {
    public void initUI() {
        Mframe jf = new Mframe();
        jf.setSize(1000, 1000);
        jf.setTitle("五子棋游戏");
        jf.setLocationRelativeTo(null);
        jf.setDefaultCloseOperation(3);

        JPanel esatPanel = new JPanel();
        esatPanel.setPreferredSize(new Dimension(80, 0));
        jf.add(esatPanel, BorderLayout.EAST);

        GameListener listener = new GameListener();
        String[] name = {"开始", "悔棋", "复盘"};
        for (int i = 0; i < name.length; i++) {
            JButton jbu = new JButton(name[i]);
            esatPanel.add(jbu);
            jbu.addActionListener(listener);
        }

        jf.setVisible(true);
        Graphics g = jf.getGraphics();


        jf.addMouseListener(listener);
        listener.setG(g);
        jf.shapeArr = listener.shapeArr;
        listener.mf = jf;
        try {
            Thread.sleep(100);
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }

        for (int i = 0; i < 9; i++) {
            g.drawLine(100, 100 + i * 100, 900, 100 + i * 100);
            g.drawLine(100 + i * 100, 100, 100 + i * 100, 900);
        }

    }

    public static void main(String[] args) {
        GameUI ui = new GameUI();
        ui.initUI();
    }
}
public class GameListener extends MouseAdapter implements ActionListener {
    private Graphics g;
    public int[][] Chess = new int[9][9];
    public int flag = 0;
    int flag1 = 0;
    int index1 = 0;
    int index2 = 0;
    public Shape[] shapeArr = new Shape[100];
    public Shape[] shapeArr0 = new Shape[100];
    public boolean start = false;
    public Mframe mf;
    int x1, y1;
    public int[] X = new int[81];
    public int[] Y = new int[81];
    public int Index = 0;

    public void setG(Graphics g) {
        this.g = g;
    }


    public void actionPerformed(ActionEvent e) {
        String str = e.getActionCommand();
        switch (str) {
            case "开始":
                flag1 = 0;
                start = true;
                for (int i = 0; i < 9; i++) {
                    for (int j = 0; j < 9; j++) {
                        Chess[i][j] = 0;
                    }
                }
                for (int i = 0; i < flag; i++) {
                    shapeArr[i] = null;
                }
                flag = 0;
                mf.paint(g);
                break;
            case "悔棋":
                if (flag >= 1) {
                    shapeArr[flag - 1] = null;
                    Chess[Y[--Index] / 100 - 1][X[--Index] / 100 - 1] = 0;
                    index1--;
                    flag--;
                }
                mf.paint(g);
                break;
            case "复盘":
                for (int i = 0; i < shapeArr.length; i++) {
                    shapeArr[i] = null;
                }
                mf.paint(g);
                for (int i = 0; i < shapeArr0.length; i++) {
                    Shape shape = shapeArr0[i];
                    if (shape == null) break;
                    try {
                        Thread.currentThread().sleep(1000);
                    } catch (InterruptedException ie) {
                        ie.printStackTrace();
                    }
                    shape.drawShape(g);
                }
                break;
        }

    }

    public void mouseClicked(MouseEvent e) {
        if (flag1 == 1) {
            System.out.println("游戏已结束！");
            return;
        }
        if (!start) {
            System.out.println("请点击开始！");
            return;
        }
        int x = e.getX();
        int y = e.getY();

        if (x % 100 <= 50) {
            x1 = x - x % 100;
        } else {
            x1 = x + 100 - x % 100;
        }
        if (y % 100 <= 50) {
            y1 = y - y % 100;
        } else {
            y1 = y + 100 - y % 100;
        }
        if (x > 900) x1 = 900;
        if (x < 100) x1 = 100;
        if (y > 900) y1 = 900;
        if (y < 100) y1 = 100;
        X[Index++] = x1;
        Y[Index++] = y1;
        if (Chess[y1 / 100 - 1][x1 / 100 - 1] != 0) {
            System.out.println("该位置已有棋子！");
            return;
        }
        if (flag % 2 == 0) {
            g.fillOval(x1 - 25, y1 - 25, 50, 50);
            Chess[y1 / 100 - 1][x1 / 100 - 1] = 1;
        } else {
            g.drawOval(x1 - 25, y1 - 25, 50, 50);
            Chess[y1 / 100 - 1][x1 / 100 - 1] = 2;
        }
        if (Iswin1(x1, y1) == 5 || Iswin2(x1, y1) == 5 || Iswin3(x1, y1) == 5 || Iswin4(x1, y1) == 5) {
            if (flag % 2 == 0) System.out.println("黑棋赢");
            else System.out.println("白棋赢");
            flag1 = 1;
        }
        Shape shape = new Shape(x1, y1, flag);
        flag++;
        shapeArr[index1++] = shape;
        shapeArr0[index2++] = shape;
    }

    public int Iswin1(int x1, int y1) {
        int c = 1;
        int a = Chess[y1 / 100 - 1][x1 / 100 - 1];
        for (int i = y1 / 100 - 2; i >= 0 && i >= y1 / 100 - 5; i--) {

            if (Chess[i][x1 / 100 - 1] == a) {
                c++;

            } else break;
        }
        for (int i = y1 / 100; i <= 8 && i <= y1 / 100 + 4; i++) {
            if (Chess[i][x1 / 100 - 1] == a) {
                c++;
            } else break;
        }

        return c;
    }

    public int Iswin2(int x1, int y1) {
        int c = 1;
        int a = Chess[y1 / 100 - 1][x1 / 100 - 1];
        for (int i = x1 / 100 - 2; i >= 0 && i >= x1 / 100 - 5; i--) {

            if (Chess[y1 / 100 - 1][i] == a) {
                c++;

            } else break;
        }
        for (int i = x1 / 100; i <= 8 && i <= x1 / 100 + 4; i++) {
            if (Chess[y1 / 100 - 1][i] == a) {
                c++;
            } else break;
        }
        return c;
    }

    public int Iswin3(int x1, int y1) {
        int c = 1;
        int a = Chess[y1 / 100 - 1][x1 / 100 - 1];
        for (int i = 1; i <= 4 && y1 / 100 - 1 - i >= 0 && x1 / 100 - 1 - i >= 0; i++) {

            if (Chess[y1 / 100 - 1 - i][x1 / 100 - 1 - i] == a) {
                c++;

            } else break;
        }
        for (int i = 1; i <= 4 && y1 / 100 - 1 + i <= 8 && x1 / 100 - 1 + i <= 8; i++) {
            if (Chess[y1 / 100 - 1 + i][x1 / 100 - 1 + i] == a) {
                c++;
            } else break;
        }
        return c;
    }

    public int Iswin4(int x1, int y1) {
        int c = 1;
        int a = Chess[y1 / 100 - 1][x1 / 100 - 1];
        for (int i = 1; i <= 4 && y1 / 100 - 1 - i >= 0 && x1 / 100 - 1 + i <= 8; i++) {

            if (Chess[y1 / 100 - 1 - i][x1 / 100 - 1 + i] == a) {
                c++;

            } else break;
        }
        for (int i = 1; i <= 4 && y1 / 100 - 1 + i <= 8 && x1 / 100 - 1 - i >= 0; i++) {
            if (Chess[y1 / 100 - 1 + i][x1 / 100 - 1 - i] == a) {
                c++;
            } else break;
        }
        return c;
    }

}

 

va学弟
关注
用java做一个简易的五子棋
AsagamiFujino的博客
05-21 6702
通过14天的Java学习，想分享自己的学习经验，这次想分享用java做一个简易的五子棋 游戏规则： (1)对局双方各执一色棋子。 (2)空棋盘开局。 (3)白先、黑后，交替下子，每次只能下一子。 (4)棋子下在棋盘的空白点上，棋子下定后，不得向其它点移动，不得从棋盘上拿掉或拿起另落别处。 (5)白方的第一枚棋子可下在棋盘任意交叉点上。 (6)任意一方达成五连子即可获胜 创建一个10*10的二维数组 static String[][] a = new String[10][10]; 初始化..
java 五子棋 简单_java实现简易五子棋游戏
weixin_30205357的博客
02-15 1506
本文实例为大家分享了java实现简易五子棋游戏的具体代码，供大家参考，具体内容如下编写一个简易五子棋，棋盘在控制台中绘制，棋盘每- - 个点都有对应的坐标，下棋者输入对应坐标落棋子,运行效果如图所示。两位数字表示的坐标中,第-一个数字表示横坐标，第二个数字表示纵坐标，运行结果如图所示。代码：package Test;import java.util.Scanner;public class Tes...
使用Java写一个简单的五子棋游戏
热爱IT行业
04-05 654
五子棋起源于中国，相传中华民族的祖先轩辕黄帝无意之中画了一些纵横交叉的线段，然后在上面摆上小石块，就想出了连五子的玩法。
用java写五子棋游戏的程序,java写简易五子棋游戏。
weixin_42312227的博客
03-10 114
import java.io.*;import java.util.*;public class 五子棋游戏{static int m=1;static int n=1;static final int SIZE=13;static final String nothing="□";static final String black="●";static final String white=...
JAVA简易五子棋游戏
qq_61813966的博客
03-25 5877
二维数组实现输入五子棋坐标开始游戏，9*9的棋盘，但是代码稍加修改就可以改变
用java做一个五子棋小游戏（课程设计）
qq_54912992的博客
06-05 1975
课程设计而已..
Java 简易五子棋游戏的编写
sea_kingdom的博客
06-21 1141
编写一个简易五子棋，棋盘在控制台中绘制，棋盘每- - 个点都有对应的坐标，下棋者输 入对应坐标落棋子,运行效果如图所示。两位数字表示的坐标中,第-一个数字表示横坐标， 第二个数字表示纵坐标，运行结果如图所示。 package Test; import java.util.Scanner; public class Test4 { public static void main(String[] args) { int flag = 0; //偶数玩家一操作，奇数玩家二操作 int works=0;
用Java写一个d简单的五子棋游戏（含人机对决，双人对决）
罗铠威的博客
11-17 1360
Java语言设计五子棋游戏，二维数组的使用，黑白棋依次重复输入下棋每下一个棋子后需要判断该棋子是否出界,此位置是否已经有棋子,判断是否有5个棋子连在一起,有则表示胜利,否则继续下棋.
Java编写简单五子棋游戏
weixin_63541561的博客
11-17 2846
编写15*15的棋盘，其中第15行和第15列表示坐标。
java实现简易五子棋游戏
08-19
Java实现简易五子棋游戏知识点总结 Java是目前最流行的编程语言之一，在游戏开发领域也具有广泛的应用。本文将详细介绍Java实现简易五子棋游戏的知识点，包括游戏设计、编程实现、游戏逻辑等方面的内容。 游戏设计...
课程设计项目-基于java实现的一个简易的五子棋对战游戏源码+项目使用说明.zip
12-29
基于java实现的一个简易的五子棋对战游戏源码.zip课程设计项目-基于java实现的一个简易的五子棋对战游戏源码+项目使用说明.zip课程设计项目-基于java实现的一个简易的五子棋对战游戏源码+项目使用说明.zip课程设计...
基于java实现的一个简易的五子棋对战游戏源码
10-11
在本项目中，我们讨论的是一个使用Java编程语言实现的简易五子棋对战游戏。五子棋是一种经典的双人策略游戏，目标是先在棋盘上形成连续的五个同色棋子（横向、纵向或斜向）的玩家获胜。这个Java实现的游戏源码为学习...
Unity_RPG开发学习笔记
最新发布
weixin_66484088的博客
07-28 651
摘要 本教程指导如何在Unity 2021.3中创建3D RPG项目，包含以下核心内容：1)创建项目并安装Universal RP渲染管线提升画面表现；2)从Asset Store导入地图、角色和天空盒素材；3)关键工具操作：光照设置、阴影调整、顶点吸附等快捷键使用；4)安装PolyBrush、ProBuilder等场景构建工具。教程配有详细图文步骤和视频链接，特别说明不同Unity版本在URP材质转换时的差异处理方法。
unity开发中Hash、Queue、LinkedList简单介绍
weixin_45478456的博客
07-27 378
摘要： Unity开发中，HashSet、Queue和LinkedList三种数据结构能高效解决特定问题： HashSet 实现O(1)极速存在性检查（如成就系统），支持自动去重和集合运算； Queue 确保先进先出的事件顺序（如AI指令队列），适合时序敏感场景； LinkedList 在动态增删（如技能连招链）时性能远超List，支持双向遍历。性能测试显示，LinkedList在中部插入/删除比List快18000倍，HashSet查找比List快42000倍。根据需求组合使用可优化游戏系统性能，如Has
APIG x OKG：游戏连接治理的「最后一公里」
阿里巴巴中间件
07-24 883
这不仅涉及连接状态的实时感知与迁移，更需要构建从基础设施到业务层的全栈治理能力，这正是实现云原生游戏连接治理的"最后一公里"。这一方案不仅继承了 Higress 的优势，更突破性地解决了传统方案在高阶能力变更时面临的连接中断问题，完美契合游戏长连接场景的严苛需求。通过这套解决方案，我们不仅缩短了云原生游戏连接治理的"最后一公里"，更为游戏服务提供商开辟了一条全新的发展道路。通过这样的部署结构，我们可以模拟复杂的游戏服务环境，为优雅下线的实验提供真实可靠的测试平台。上的优雅下线全流程。
GM68311_VC1：虚拟7.1与AI降噪游戏声卡固件技术解析
2402_85006673的博客
07-25 793
GM68311_VC1是一款运行在A316-Mini-V1模组上的高性能游戏声卡固件，支持USB输入到I²S输出的音频传输，并具备I²S输入到USB输出的双向传输能力。该固件集成了SA虚拟7.1算法和AI DNR深度学习降噪技术，专为提升游戏音频沉浸感和语音通话清晰度而设计。
Unity GC 系列教程第五篇：高级 GC 内核
qq_46348216的博客
07-25 1255
本文是Unity GC优化系列教程的完结篇，重点介绍高级内存管理技术。首先探讨ScriptableObject如何通过数据与逻辑分离减少GC压力，并分析静态数据的使用注意事项。接着解析IL2CPP对GC性能的间接提升作用。最后介绍C# Job System、Burst Compiler和Native Container等高性能计算技术，这些不仅能避免GC分配，还能实现并行计算带来性能飞跃。文章还展望了.NET和Unity引擎在GC优化方面的未来发展。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值