JAVA 五子棋（人机）昨天买的棋子今天就用不上了

最新推荐文章于 2025-11-25 08:17:12 发布
原创 最新推荐文章于 2025-11-25 08:17:12 发布 · 318 阅读 · 2 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。

本文介绍了一种使用Java实现五子棋游戏的方法。通过创建10*10的棋盘并利用二维数组来存储棋子位置，实现了基本的棋盘布局。接着详细介绍了玩家交替下子的过程，并对坐标有效性进行验证，确保不会在同一位置重复下子。最后，通过四个不同的函数检查横向、纵向及两个方向的斜线是否达到五子连线的情况来判断输赢。

五子棋 JAVA

首先我们应该思考五子棋是由哪些东西组成的

1、棋盘，假设我们要创建一个10*10的棋盘，应该使用数组且为二维数组

public class QP {
   static String[][]a=new String[10][10];
    public static void main(String[] args) {
      Qi();
      Pan();
      Zi();
    }

由于下面要创建方法，为了方便，将数组定义为成员变量

 public static void Qi(){
        for (int i = 0; i <a.length; i++) {
            for (int j = 0; j <a[i].length ; j++) {
                a[j][i]="+";
            }System.out.println();
        }
    }

创建一个方法使其循环

第一个循环代表的是打印的行数比数组长度少一行

第二个循环代表每一行打印多少个

定义a [j] [i]="+";然后让他们换行

出来的效果就是在数组中将"+"存进去

 public static void Pan(){
        for (int i = 0; i <a.length; i++) {
            for (int j = 0; j <a[i].length ; j++) {
                System.out.print(a[j][i]+"\t");
            }System.out.println();
        }
    }

接着在创建一个方法，让他能够调用数组里存的"+",并将他显示出来，至此棋盘创建成功

2、接下来就是要开始下子了

单独创建一个方法

我们来分析一下下子的逻辑

首先下子要分为两方对弈，所以会有前后两次的输入来在棋盘上确认一点然后完成下子

其次下的子肯定不能重复下在同一个坐标上

比如下了一个黑子坐标（1，,1），接着又下了一个白子坐标也是（1,1）

那么要判定（1,1）这个坐标到底是哪种颜色的子呢？所以不能下在同一个坐标，也不能下出棋盘

 public static void Zi(){
        Scanner s = new Scanner(System.in);
        boolean flag = true;
         int x = 0;
         int y = 0;
        while (true){
            if (flag){
                System.out.println("空心先下");
                 x = s.nextInt();
                 y = s.nextInt();
                if (x>10||x<1||y>10||y<1){
                    System.out.println("重新输入");
                    continue;
                }
                if (!a[y-1][x-1].equals("○")&&!a[y-1][x-1].equals("●")){
                    a[y-1][x-1] = "○";
                }else {

                    System.out.println("重新输入");
                    continue;
                }
            }else {
                System.out.println("实心后下");
                 x = s.nextInt();
                 y = s.nextInt();
                if (x>10||x<1||y>10||y<1){
                    System.out.println("重新输入");
                    continue;
                }
                if (!a[y-1][x-1].equals("○")&&!a[y-1][x-1].equals("●")){
                    a[y-1][x-1] = "●";
                }else {
                    System.out.println("重新输入");
                    continue;
                }
            }
            Pan();
            flag = !flag;

先创建一个布尔类型boolean flag = true;

再创建一个while死循环，一直为true

[y-1] [x-1]是因为我们按照习惯输入的数肯定是从1开始的，但是[y-1]是数组的下标，数字中的0，可以看作平常的1，所以要把输入的x,y坐标都减一，这样才能正确找到相应数组的下标

循环内有两种情况，一种是flag = true时，白子下

要先判断他能下坐标的范围，也就是横坐标大于1，小于10，纵坐标大于1，小于10的时候输出“重新输入”并且下边的代码都不执行，判断输入的坐标里不是黑子，也不是白子，也就是"+";那么下白子，如果棋盘上不是"+";要重新输入，并且下面的代码不执行

flag = false，黑子下

原理与判断白子相同

每次下子都重新打印棋盘

每次循环 flag = !flag，也就是每次进入循环的值都不一样，一次为true，下一次就是false，就会形成白子下一次，黑子下一次

接着就是判断输赢

要判断输赢，我们要明白赢的方式有哪些

一、五个相同的棋子连成一条线

二、横着连五个

三、竖着连五个

四、斜着连五个——1、左边在上右边在下的连五子 2、左边在下右边在上的连五子

也就是会有四种情况来判断赢

我们每一种情况都创建一个方法

横着连五个

public static boolean Ying(int x,int y,String s){
        int count = 1;
        int i = x;
        int j = y-1;
        for (; j >=0 ; j--) {
            if (a[j][i].equals(s)){
                count++;
            }else{
                break;
            }
        }
        int k = y+1;
        for (; k <=9 ; k++) {
            if (a[k][i].equals(s)){
                count++;
            }else{
                break;
            }
        }
        if (count>=5){
            System.out.println("win");
            return true;
        }
        return false;
    }

横着连五个又有两种判断

1、判断以一个子为原点向左找是否连成5个，但是不能小于0，判断成功，那么这个坐标的左边是和他相同的棋子，棋子连成的长度加一

在这里插入图片描述

2、判断以一个子为原点向右找是否连成5个，但是不能大于9，判断成功，那么这个坐标的左边是和他相同的棋子，棋子连成的长度加一
在这里插入图片描述

如果棋子连成的长度大于等于5，那么就是这种棋子赢，如果是，就停止这个程序

竖着连五个

public static boolean Ying1(int x,int y,String s){
        int count = 1;
        int i = x-1;
        int j = y;
        for (; i >=0 ; i--) {
            if (a[j][i].equals(s)){
                count++;
            }else{
                break;
            }
        }
        int k = x+1;
        for (; k <=9 ; k++) {
            if (a[j][k].equals(s)){
                count++;
            }else{
                break;
            }
        }
        if (count>=5){
            System.out.println("win");
            return true;
        }
        return false;
    }

竖着连五个又有两种判断

1、判断以一个子为原点向上找是否连成5个，但是不能小于0，判断成功，那么这个坐标的上边是和他相同的棋子，棋子连成的长度加一
在这里插入图片描述

2、判断以一个子为原点向下找是否连成5个，但是不能大于9，判断成功，那么这个坐标的下边是和他相同的棋子，棋子连成的长度加一
在这里插入图片描述

如果棋子连成的长度大于等于5，那么就是这种棋子赢，如果是，就停止这个程序

左边在上右边在下的连五子

 public static boolean Ying2(int x,int y,String s){
        int count = 1;
        int i = x-1;
        int j = y-1;
        for (; i >=0&& j>=0; i--,j--) {
            if (a[j][i].equals(s)){
                count++;
            }else{
                break;
            }
        }
        int k = x+1;
        int z = y+1;
        for (; k <=9 &&z<=9; k++,z++) {
            if (a[z][k].equals(s)){
                count++;
            }else{
                break;
            }
        }
        if (count>=5){
            System.out.println("win");
            return true;
        }
        return false;
    }

我们来看一下这种判断方式

也是以一个子为原点来判断他相邻的那个棋子是不和他一样

左上

就是x坐标，y坐标同时减一来判断相邻在这里插入图片描述

右下

就是x坐标，y坐标同时加一来判断相邻在这里插入图片描述

如果判断五个相同的连在一起，就判赢

左边在下右边在上的连五子

 public static boolean Ying3(int x,int y,String s){
        int count = 1;
        int i = x-1;
        int j = y+1;
        for (; i >=0&&j<=9 ; i--,j++) {
            if (a[j][i].equals(s)){
                count++;
            }else{
                break;
            }
        }
        int k = x+1;
        int z = y-1;
        for (; k <=9 && z>=0; k++, z--) {
            if (a[z][k].equals(s)){
                count++;
            }else{
                break;
            }
        }
        if (count>=5){
            System.out.println("win");
            return true;
        }
        return false;
    }
}

左下

x坐标减一，y坐标加一在这里插入图片描述

右上

x坐标加一，y坐标减一在这里插入图片描述

至此有了四种判断方式，任意一种判断出为赢就可以结束程序了
完整程序如下

import jdk.nashorn.internal.ir.ContinueNode;

import java.util.Scanner;

public class QP {
   static String[][]a=new String[10][10];
    public static void main(String[] args) {
      Qi();
      Pan();
      Zi();
    }

    public static void Qi(){
        for (int i = 0; i <a.length; i++) {
            for (int j = 0; j <a[i].length ; j++) {
                a[j][i]="+";
            }System.out.println();
        }
    }

    public static void Pan(){
        for (int i = 0; i <a.length; i++) {
            for (int j = 0; j <a[i].length ; j++) {
                System.out.print(a[j][i]+"\t");
            }System.out.println();
        }
    }
    public static void Zi(){
        Scanner s = new Scanner(System.in);
        boolean flag = true;
         int x = 0;
         int y = 0;
        while (true){
            if (flag){
                System.out.println("空心先下");
                 x = s.nextInt();
                 y = s.nextInt();
                if (x>10||x<1||y>10||y<1){
                    System.out.println("重新输入");
                    continue;
                }
                if (!a[y-1][x-1].equals("○")&&!a[y-1][x-1].equals("●")){
                    a[y-1][x-1] = "○";
                }else {

                    System.out.println("重新输入");
                    continue;
                }
            }else {
                System.out.println("实心后下");
                 x = s.nextInt();
                 y = s.nextInt();
                if (x>10||x<1||y>10||y<1){
                    System.out.println("重新输入");
                    continue;
                }
                if (!a[y-1][x-1].equals("○")&&!a[y-1][x-1].equals("●")){
                    a[y-1][x-1] = "●";
                }else {
                    System.out.println("重新输入");
                    continue;
                }
            }
            Pan();
            flag = !flag;
            boolean res = Ying(x-1,y-1,a[y-1][x-1]);
            if (res){
                break;
            }
            boolean res1 = Ying1(x-1,y-1,a[y-1][x-1]);
            if (res1){
                break;
            }
            boolean res2 = Ying2(x-1,y-1,a[y-1][x-1]);
            if (res2){
                break;
            }
            boolean res3 = Ying3(x-1,y-1,a[y-1][x-1]);
            if (res3){
                break;
            }
        }
    }

    public static boolean Ying(int x,int y,String s){
        int count = 1;
        int i = x;
        int j = y-1;
        for (; j >=0 ; j--) {
            if (a[j][i].equals(s)){
                count++;
            }else{
                break;
            }
        }
        int k = y+1;
        for (; k <=9 ; k++) {
            if (a[k][i].equals(s)){
                count++;
            }else{
                break;
            }
        }
        if (count>=5){
            System.out.println("win");
            return true;
        }
        return false;
    }


    public static boolean Ying1(int x,int y,String s){
        int count = 1;
        int i = x-1;
        int j = y;
        for (; i >=0 ; i--) {
            if (a[j][i].equals(s)){
                count++;
            }else{
                break;
            }
        }
        int k = x+1;
        for (; k <=9 ; k++) {
            if (a[j][k].equals(s)){
                count++;
            }else{
                break;
            }
        }
        if (count>=5){
            System.out.println("win");
            return true;
        }
        return false;
    }

    public static boolean Ying2(int x,int y,String s){
        int count = 1;
        int i = x-1;
        int j = y-1;
        for (; i >=0&& j>=0; i--,j--) {
            if (a[j][i].equals(s)){
                count++;
            }else{
                break;
            }
        }
        int k = x+1;
        int z = y+1;
        for (; k <=9 &&z<=9; k++,z++) {
            if (a[z][k].equals(s)){
                count++;
            }else{
                break;
            }
        }
        if (count>=5){
            System.out.println("win");
            return true;
        }
        return false;
    }


    public static boolean Ying3(int x,int y,String s){
        int count = 1;
        int i = x-1;
        int j = y+1;
        for (; i >=0&&j<=9 ; i--,j++) {
            if (a[j][i].equals(s)){
                count++;
            }else{
                break;
            }
        }
        int k = x+1;
        int z = y-1;
        for (; k <=9 && z>=0; k++, z--) {
            if (a[z][k].equals(s)){
                count++;
            }else{
                break;
            }
        }
        if (count>=5){
            System.out.println("win");
            return true;
        }
        return false;
    }
}
Java五子棋（人机版），昨天买的棋子今天就用不上了
编程界明世隐的博客
07-20 5万+
作者简介 作者名：编程界明世隐 简介：优快云博客专家，从事软件开发多年，精通Java、JavaScript，博主也是从零开始一步步把学习成长、深知学习和积累的重要性，喜欢跟广大ADC一起打野升级，欢迎您关注，期待与您一起学习、成长、起飞！ 系列项目 1. Java俄罗斯方块 2. 老Java程序员花2天写了个连连看 3. 老Java程序员花一天时间写了个飞机大战 4. Java植物大战僵尸 5. Java消消乐（天天爱消除） 6. Java贪吃蛇小游戏 7. Java扫雷小游戏 8. Java坦克大战
用java实现五子棋
weixin_35752122的博客
12-20 614
好的，我来给你介绍一下如何使用 Java 来实现五子棋游戏。 首先，你需要准备一个二维数组来表示棋盘，其中 0 表示这个位置没有棋子，1 表示黑色棋子，2 表示白色棋子。 然后你需要编写一个函数来判断当前局面是否有一方胜利。可以按如下步骤来判断： 枚举棋盘上的每一个位置，如果这个位置有棋子，就向四个方向(上下左右)扩展，如果有五个连续的相同颜色的棋子，就表示这一方胜利。 如果棋盘已经满了，但是没...
Java 实现五子棋
最新发布
2501_90980137的博客
11-25 945
采用面向对象思想，将五子棋拆分为棋盘类（Chessboard）、棋子类（ChessPiece）、游戏逻辑类（GobangGame）和主程序类（GobangMain），各司其职降低耦合。currentPlayer = currentPlayer.equals("黑")?"白" : "黑";} else if (board[i][j].getColor().equals("黑")) {System.out.print("请" + currentPlayer + "棋落子：");
java五子棋
meiyijian的博客
08-11 8817
java五子棋总结 刚刚学习java不久，尝试自己做了一个五子棋先附上一个运行效果的图： 五子棋的主要目的： 1.练习java面向对象的编程思想 2.掌握监听器的使用（鼠标监听器） 制作五子棋为了代码的可扩充性，我们首先要定义一个五子棋的各个属性的接口： /** * 五子棋的相关属性 * @author Administrator * */ public int
Java五子棋
m0_58730471的博客
08-15 3039
java，小游戏，五子棋，大作业
JAVA五子棋
smdnzhan的博客
09-24 773
一个简单的JAVA小项目，主要实现的功能有： 一、下棋功能，在棋盘的交点处落子。 二、悔棋功能，取消最后一颗下的棋子。 三、简单人机对战功能。 1.窗体实现。主要使用了JFrame类 public class GameUI { public static void main(String[] args) { GameUI ui = new GameUI(); ui.showUI(); } //显示游戏界面 public vo
java五子棋课设（含人机对战）.rar
07-28
②可两人对下：使用鼠标监听器和15*15的二维数组表示棋盘上棋子的状态。 ③判断输赢：每次根据下棋位置更新二维数组后对齐进行行、列、斜的判断，当存在五子连珠时弹出窗口，根据一系列状态变量判断黑方/白方获胜。 ...
java五子棋人机对战
03-13
在本项目中，"java五子棋人机对战"是一个使用Java编程语言实现的五子棋游戏。这个游戏不仅提供了人机对战模式，还支持玩家之间的对战，展现了Java在开发交互式游戏方面的应用。下面我们将深入探讨相关知识点。 1. *...
java五子棋人机对战项目
11-10
【Java五子棋人机对战项目】是一个利用JavaSwing图形用户界面库开发的桌面游戏应用程序，专注于提供一个互动的五子棋游戏环境。在这个项目中，玩家可以与计算机进行对弈，体验到一定程度的智能挑战。智能的实现主要...
java五子棋人机人人
01-13
Java五子棋人机人人项目是一个利用Java编程语言实现的五子棋游戏，它支持人与人对战、人与计算机对战以及计算机与计算机之间的对战模式。在这个项目中，我们将探讨Java编程基础、图形用户界面（GUI）设计、算法实现...
java游戏之五子棋
12-07
java游戏五子棋，更多开源游戏见博客http://blog.youkuaiyun.com/simon_world
基于Java实现的五子棋
08-31
基于JAVA语言，开发五子棋游戏，新增分数机制，不死机制等
Java实现五子棋
01-16
下载后是一个txt，txt内有百度云链接和直链 包含完整代码，是用eclipse写的，下载即可运行，新手可以参考下 如有问题，请联系邮箱：aliulf@foxmail.com
java实现五子棋
12-03
java实现的五子棋，加入智能落子功能 java实现的五子棋，加入智能落子功能
简单五子棋
Wen先森的博客
12-30 266
package demo; import java.util.Scanner; public class GoBang { //声明一个二维数组存储棋盘的行和列。 private static char[][] ChessBoard; //声明棋盘行和列的序号（即定义坐标） private static char[]number= { '1','2','3','4','5','6','7','8','9', 'A','B','C','D','E','F','G','H','I'.
【Java之五子棋】——java五子棋游戏
热门推荐
qq_50497708的博客
01-09 1万+
基本思路： 1.先有一个界面可以弹出窗口，在界面上重写paint方法，在这个方法里加入棋盘，使得棋盘可以不断重绘，不会因为刷新而消失； 2.创建鼠标监听器，为了让鼠标监听器界面可以下黑白棋子； 3.再创建一个判断输赢的类，可以用数组来存储棋子 接下来完成具体步骤： 1.创建一个Gobang的类，继承了JFrame的功能，因此以前会写jf.setTitle("五子棋")；这里就可以用this代替或者不写，下面这四个就是分别用了这两个方法 2.重写paint方法，绘制棋盘 可以先画两条直线
Java小游戏——五子棋
weixin_51937688的博客
04-29 2939
文章目录内容简介一、规则二、具体代码实现1.调试环境2.代码实现3.运行演示小结彩蛋 内容简介 本文介绍了一个修改自某位大佬的五子棋小游戏qwq 目前可以实现简单的双人对战~ 原文传送门 GitHub传送门 以下是本篇文章正文内容 一、规则 本程序作为基础的五子棋，连成五个即可获胜，没有设置禁手。 注：五子棋RIF规则中黑棋只能以“四、三”取胜 二、具体代码实现 1.调试环境 开发环境为Eclipse。 2.代码实现 大致结构 具体代码如下： 1.GoBangframe类 package GoBang
JAVA简单五子棋
weixin_47596965的博客
06-08 1451
JAVA简单五子棋，这几天刚做的，放在优快云也是为了保存自己的成果吧。``因为只是一名大一生刚接触java所以有些专业词用的不到位。见谅见谅，也没有做悔棋和剩余时间，嘿嘿 package com.Swing; import java.awt.BasicStroke; import java.awt.Color; import java.awt.Font; import java.awt.Frame; import java.awt.Graphics; import java.awt.Graphics2D;
JAVA五子棋人机对战练习项目源码分享
根据提供的文件信息，以下是对“java五子棋 人机对战 源码及素材”的知识点详细说明： ### 1. Java编程基础 首先，要了解Java五子棋游戏的开发涉及到Java基础编程知识。这包括但不限于Java语法、面向对象的编程思想...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值