编程细胞

用户名：Floatingdream

访问量：12517

签　名：

简简单单每天收获一点

等　　级
排　　名	311
经　　验	5524
参赛次数	7
文章发表	20
年　　龄	21
在职情况	学生
学　　校	家里蹲大学
专　　业	物联网工程

　　自我简介：

菜鸟一枚

TA的其他文章

算法学习资料推荐
浏览：238

你可能喜欢

A+B for Input-Output Practice (VII) （C++代码）

Java小游戏之五子棋

　　作者: 编程细胞　　　　发表时间：2020-04-11 19:32:58 浏览：717　|　评论：1　

## 0. 推箱子的基本信息

- 作者：冥冥之中立刻有

- `QQ号`：2698111472

- `QQ学习群`：290397456

## 1. 项目的准备

### 1.1 使用的开发工具

- IDEA工具

### 1.2 项目的目录结构

![](/image_editor_upload/20200411072901_52113.png)

### 1.3 项目资料以及图片

- 加`QQ群`：290397456
- 通过网上去找，可能比较难找

## 2. 建立TestFiveChessFrame.java文件

### 2.1 TestFiveChessFrame.java中的代码

```java
package com.mingri.Mygame.test;

import com.mingri.Mygame.java.FiveChessFrame;

public class TestFiveChessFrame {
    public static void main(String[] args) {
        //创建FiveChessFrame对象
        FiveChessFrame fiveChessFrame = new FiveChessFrame();// Alt+回车
    }
}
```

### 2.2 解释说明

- 该Java文件用于运行代码，是执行程序的入口类。
- 该类主要就是创建FiveChessFrame对象，显示窗体。

## 3. 建立FiveChessFrame.java文件

### 3.1 FiveChessFrame.java文件说明

- 该类需要继承JFrame类，用于显示体窗口
- 该类还继承了两个接口 MouseListener, Runnable
- MouseListener接口，用于鼠标监听
- Runnable接口，用于实现线程

### 3.2 主要的代码

```java
package com.mingri.Mygame.java;

import javax.imageio.ImageIO;
import javax.swing.*;
import java.awt.*;
import java.awt.event.MouseEvent;
import java.awt.event.MouseListener;
import java.awt.image.BufferedImage;
import java.io.File;
import java.io.IOException;

public class FiveChessFrame extends JFrame implements MouseListener, Runnable {

//获取屏幕大小
    int width = Toolkit.getDefaultToolkit().getScreenSize().width;  //屏幕的宽度
    int height = Toolkit.getDefaultToolkit().getScreenSize().height;//屏幕的高度
    
    //构造方法
    public FiveChessFrame() {
        this.setTitle("五子棋");//设置窗体标题
        this.setSize(500, 500);//设置窗体大小
        this.setResizable(false);//设置窗体是否可以改变大小
        this.setLocation((width - 500) / 2, (height - 500) / 2);//设置窗体初始显示位置
        this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);//设置窗体关闭方式
        //加入鼠标监听器
        this.addMouseListener(this);

//设置窗体是否显示
        this.setVisible(true);

//启动线程
        t.start();
        //将线程挂起
        t.suspend();

//刷新屏幕，防止游戏时出现无法显示的情况
        this.repaint();

}
    //...省略其他方法的实现...
}
```

## 4. 简单介绍项目中继承的接口与方法

### 4.1 Frame类

#### 4.1.1 概念

- JFrame是创建窗体的swing类，用类创建一个图形界面的原始窗口，并设置其大小，位置等属性，是swing编程的基础类之一

#### 4.1.2 JFrame类中的主要方法

- setVisible(boolean值); ——》设置窗体是否显示 
  - true表示显示窗体
  - false表示不显示窗体
- setTitle(String类型); ——》设置窗体标题
- setSize(宽,高); ——》设置窗体大小
- setLocation(x,y); ——》设置窗体初始显示位置
- setResizable(boolean值); ——》设置窗体是否可以改变大小 
  - true代表可以改变窗体大小（默认为true）
  - false代表不能改变窗体大小
- setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); ——》设置窗体关闭方式 
  -  JFrame.EXIT_ON_CLOSE：代表关闭窗体时同时结束程序

- 获取屏幕的大小
  - int width = Toolkit.getDefaultToolkit().getScreenSize().width;   ——》屏幕的宽度
  - int height = Toolkit.getDefaultToolkit().getScreenSize().height; ——》屏幕的高度

### 4.2 MouseListener接口

#### 4.2.1 概念

- 接受用户通过鼠标所做的操作。可以取得用户点击鼠标的坐标

#### 4.2.2 需要重写的方法（5个）

- mouseClicked(MouseEvent e)    ——》监听鼠标点击事件的操作
- mousePressed(MouseEvent e)   ——》监听鼠标按下事件的操作
- mouseReleased(MouseEvent e) ——》监听鼠标松开事件的操作
- mouseEntered(MouseEvent e)   ——》监听鼠标进入事件的操作
- mouseExited(MouseEvent e)      ——》监听鼠标离开事件的操作

#### 4.2.3 代码展示

```java
package com.mingri.Mygame.java;

import javax.swing.*;
import java.awt.*;
import java.awt.event.MouseEvent;
import java.awt.event.MouseListener;

/*
鼠标点击时执行的顺序：<1>鼠标按下
				  <2>鼠标松开
				  <3>鼠标点击（必须是鼠标在同一位置按下松开，才会执行鼠标点击）
*/

public class MyChessFrame extends JFrame implements MouseListener {
    public MyChessFrame(){
        //...省略窗体设置的代码...

//加入鼠标监听器
        this.addMouseListener(this);

this.setVisible(true);//设置窗体是否显示
    }

@Override
    public void mouseClicked(MouseEvent e) {//监听鼠标点击事件的操作
       
    }

@Override
    public void mousePressed(MouseEvent e) {//监听鼠标按下事件的操作
       
    }

@Override
    public void mouseReleased(MouseEvent e) {//监听鼠标松开事件的操作
        
    }

@Override
    public void mouseEntered(MouseEvent e) {//监听鼠标进入事件的操作
        
    }

@Override
    public void mouseExited(MouseEvent e) {//监听鼠标离开事件的操作
        
    }
}
```

#### 4.2.4 获取鼠标的点击坐标

```java
//获取鼠标点击位置
System.out.println("点击位置：x--》" + e.getX());//得到鼠标的横向位置的坐标
System.out.println("点击位置：y--》" + e.getY());//得到鼠标的纵向位置的坐标
```

### 4.3 Runnable接口

#### 4.3.1 概念

- 该接口用于实现线程，相关介绍百度比较全面

#### 4.3.2 需要重写的方法（1个）

```java
package com.mingri.Mygame.java;

//创建线程对象
Thread t = new Thread(this);

public class FiveChessFrame extends JFrame implements MouseListener, Runnable {

//...省略窗体的设置相关代码...
        
        //启动线程
        t.start();
        //将线程挂起
        t.suspend();
    }
    
    //Runnable接口需要重写的方法
    @Override
    public void run() {
        
    }
    
}
```

## 5. 项目中用到的其他类

### 5.1 JOptionPane类

#### 5.1.1 概念

- 用于弹出提示信息框，确认框和信息输入框

#### 5.1.2 showMessageDialog(窗体对象，弹出的信息（Object）);

##### 5.1.2.1 方法解释

- 显示一个消息对话框，主要用来提示信息 ——》只有一个确认的选项

##### 5.1.2.2 代码实现

```java
//显示一个消息对话框，主要用来提示信息--》只有一个确认的选项
JOptionPane.showMessageDialog(myChessFrame,"提示信息");
```

##### 5.1.2.3 图片展示

![](/image_editor_upload/20200411072944_84799.png)

#### 5.1.3 int result = JOptionPane.showConfirmDialog(窗体对象,弹出的信息(Object));

##### 5.1.3.1 方法解释

- 显示一个消息对话框，会有三个选项，返回一个int类型的值
- 是（0），否（1），取消（2），右上角的【×】（-1）

##### 5.1.3.2 代码展示

```java
//显示一个消息对话框，会有三个选项：是（0），否（1），取消（2），叉叉（-1），返回一个int类型的值
int result = JOptionPane.showConfirmDialog(myChessFrame, "我的确认信息，现在要开始游戏吗？");
//System.out.println(result);
if (result == 0) {
    JOptionPane.showMessageDialog(myChessFrame, "游戏开始");
} else if (result == 1) {
    JOptionPane.showMessageDialog(myChessFrame, "游戏结束");
} else if (result == 2) {
    JOptionPane.showMessageDialog(myChessFrame, "请重新选择");
}
```

##### 5.1.3.3 图片展示

![](/image_editor_upload/20200411073003_14941.png)

#### 5.1.4 String 接收返回值的对象 = JOptionPane.showInputDialog(弹出的信息(Object));

##### 5.1.4.1 方法解释

- 显示一个可输入的对话框，返回一个String类型的值，作用是用来保存用户输入的信息

##### 5.1.4.2 代码展示

```java
//显示一个可输入的对话框，返回一个String类型的值
String username = JOptionPane.showInputDialog("请输入你的姓名：");
//System.out.println(username);
if (username != null) {
    JOptionPane.showMessageDialog(myChessFrame, "输入的姓名为：" + username);
} else {
    JOptionPane.showMessageDialog(myChessFrame, "请重新输入你的姓名！");
}
```

##### 5.1.4.3 图片展示

![](/image_editor_upload/20200411073022_92530.png)

### 5.2 Graphics类

#### 5.2.1 基础介绍

- 功能：类似画笔，用来在窗口中绘制文字和图像
- 通过覆写JFrame的paint()方法来使用，通过repaint()方法来调用
- paint()方法：用于绘制文字和图像
- repaint()方法：用于重新执行一次paint()方法

#### 5.2.2 常用的方法

- drawString("显示的字体",x,y); ——》绘制字符串
- drawOval(x,y,width,height); ——》绘制一个空心的圆形 ——》坐标+横向直径+纵向直径
- fillOval(x,y,width,height); ——》绘制一个实心的圆形     ——》坐标+横向直径+纵向直径
- drawRect(x,y,width,height); ——》绘制一个空心的矩形
- fillRect(x,y,width,height); ——》绘制一个实心的矩形
- drawLine(起点坐标,终点坐标);——》绘制一条直线
- setColor(Color.blue); ——》设置画笔颜色
- setFont(new Font("字体格式",字体样式,字体大小));——》设置绘制文字的字体

#### 5.2.3 加载图片的两种方法

```java
public void paint(Graphics graphics){
    //加载图片方法一：
    //抛出异常快捷键：Ctrl+Alt+T
    BufferedImage image01 = null;
    //加载图片
    try {
        image01 = ImageIO.read(new File("图片路径"));
    } catch (IOException e) {
        e.printStackTrace();
    }
    //绘制一个已经存在的图片，将一个图片直接显示到窗体中
    graphics.drawImage(image01,0,0,this);
    
    //加载图片方法二：
     Image image02 = new ImageIcon("图片路径“).getImage();
     graphics.drawImage(image02, 0, 0, this);
                                   
    //...省略其他绘制的代码...

}
```

#### 5.2.4 防止闪屏的相关代码

```java
public void paint(Graphics graphics) {
    //双缓冲技术--》防止屏幕闪烁--》屏幕大小+缓冲类型
    BufferedImage bi = new BufferedImage(500, 500, BufferedImage.TYPE_INT_ARGB);
    Graphics graphics2 = bi.createGraphics();
    
    //...省略部分绘制的代码...
    //这里都是用对象graphics2来绘制
    
    graphics.drawImage(bi, 0, 0, this);
}   
```

## 6. 主要的方法实现

### 6.1 绘制图形的方法

```java
	//保存之前下过的全部棋子的坐标
    //其中数据内容为：0 --》表示这个点上没有棋子
    //其中数据内容为：1 --》表示这个点上为黑子
    //其中数据内容为：2 --》表示这个点上为白子
    int[][] allChess = new int[19][19];

public void paint(Graphics graphics) {
            //双缓冲技术--》防止屏幕闪烁
            BufferedImage bi = new BufferedImage(500, 500, BufferedImage.TYPE_INT_ARGB);//屏幕大小+缓冲类型
            Graphics graphics2 = bi.createGraphics();

graphics2.setColor(Color.BLACK);//把颜色改为黑色
            //加载图片
            try {
                bgImage = ImageIO.read(new File("图片路径"));
            } catch (IOException e) {
                e.printStackTrace();
            }
            //绘制一个已经存在的图片，将一个图片直接显示到窗体中
            graphics2.drawImage(bgImage, 1, 20, this);

//绘制游戏的文字信息
            //设置绘制文字的字体-->Font.BOLD(加粗)
            graphics2.setFont(new Font("黑体", Font.BOLD, 20));
            //绘制字符串
            graphics2.drawString("游戏信息：" + message, 130, 60);

//绘制黑方的文字信息
            //设置绘制文字的字体
            graphics2.setFont(new Font("宋体", 0, 14));
            //绘制字符串
            graphics2.drawString("黑方时间：" + blackMessage, 30, 470);

//绘制白方的文字信息
            //设置绘制文字的字体
            graphics2.setFont(new Font("宋体", 0, 14));
            //绘制字符串
            graphics2.drawString("白方时间：" + whiteMessage, 260, 470);

//绘制棋盘 19 X 19
            for (int i = 0; i < 19; i++) {
                //绘制一条直线-->横向
                graphics2.drawLine(10, 70 + 20 * i, 370, 70 + 20 * i);
                //绘制一条直线-->纵向
                graphics2.drawLine(10 + 20 * i, 70, 10 + 20 * i, 430);
            }

//标注点位 (9个点)
            //都为实心圆，圆的半径为：2像素
            //左上
            graphics2.fillOval(68, 128, 4, 4);
            //右上
            graphics2.fillOval(308, 128, 4, 4);
            //右下
            graphics2.fillOval(308, 368, 4, 4);
            //左下
            graphics2.fillOval(68, 368, 4, 4);
            //中心点
            graphics2.fillOval(188, 248, 4, 4);
            //上中
            graphics2.fillOval(188, 128, 4, 4);
            //下中
            graphics2.fillOval(188, 368, 4, 4);
            //左中
            graphics2.fillOval(68, 248, 4, 4);
            //右中
            graphics2.fillOval(308, 248, 4, 4);

//绘制全部棋子
            for (int i = 0; i < 19; i++) {
                for (int j = 0; j < 19; j++) {
                    if (allChess[i][j] == 1) {//绘制黑子
                        int tempx = j * 20 + 10;//列
                        int tempy = i * 20 + 70;//行
                        graphics2.setColor(Color.BLACK);//把颜色改为黑色
                        graphics2.fillOval(tempx - 7, tempy - 7, 14, 14);

} else if (allChess[i][j] == 2) {//绘制白子
                        int tempx = j * 20 + 10;//列
                        int tempy = i * 20 + 70;//行
                        graphics2.setColor(Color.WHITE);//把棋子颜色改为白色
                        graphics2.fillOval(tempx - 7, tempy - 7, 14, 14);
                        //给棋子加上一个黑色的边框
                        graphics2.setColor(Color.BLACK);//把颜色改为黑色
                        graphics2.drawOval(tempx - 7, tempy - 7, 14, 14);
                    }
                }
            }
            graphics.drawImage(bi, 0, 0, this);
    }

```

### 6.2 落子的方法

```java
   //标识当前应该是黑棋，还是白棋
    boolean isBlack = true;

//标识当前游戏是否可以继续
    boolean canPlay = true;

@Override
public void mousePressed(MouseEvent e) {//监听鼠标按下事件的操作
    /*//获取鼠标点击位置
    System.out.println("点击位置：x--》" + e.getX());//得到鼠标的横向位置的坐标
    System.out.println("点击位置：y--》" + e.getY());//得到鼠标的纵向位置的坐标*/

if (canPlay == true) {
        //获取鼠标点击位置
        x = e.getX();
        y = e.getY();
        //整个棋盘大小：左上（10，70），右下（370，430）
        if (x >= 10 && x <= 370 && y >= 70 && y <= 430) {
            x = (x - 10) / 20;//列
            y = (y - 70) / 20;//行
            if (allChess[y][x] == 0) {
                //判断当前下的是什么棋子
                if (isBlack == true) {//黑子
                    allChess[y][x] = 1;
                    isBlack = false;
                    message = "轮到白方下棋";
                } else {//白子
                    allChess[y][x] = 2;
                    isBlack = true;
                    message = "轮到黑方下棋";
                }

//判断游戏是否结束
                boolean winFlag = this.checkWin();
                if (winFlag == true) {
                    JOptionPane.showMessageDialog(this, "游戏结束！！！\n"
                            + (allChess[y][x] == 1 ? "【黑方】" : "【白方】") + "获胜！");
                    canPlay = false;//让游戏终止
                    if (canPlay == false) {
                        message = "游戏结束";
                        this.repaint();
                    }
                }
            } else {
                //提示信息
                JOptionPane.showMessageDialog(this, "当前位置有棋子\n请重新下！！！");
            }

//repaint();重新绘制棋盘
            this.repaint();
        }
    }
    //...省略6个按钮的实现...
}
```

### 6.3 判断五子棋输赢（第一种）

```java
//判断游戏输赢
private boolean checkWin() {
    //判断输赢的变量
    boolean flag = false;
    //保存棋子颜色
        int color = allChess[y][x];
        //横向判断
        int count = this.checkCount(1, 0, color);
        if (count >= 5) {
            flag = true;
        } else {
            //纵向判断
            count = this.checkCount(0, 1, color);
            if (count >= 5) {
                flag = true;
            } else {
                //斜方向的判断：右上+左下 --》列减少，行增加
                count = this.checkCount(-1, 1, color);
                if (count >= 5) {
                    flag = true;
                } else {
                    //斜方向的判断：左上+右下 --》列增加，行增加
                    count = this.checkCount(1, 1, color);
                    if (count >= 5) {
                        flag = true;
                    }
                }
            }
        }
        return flag;
    }

//判断棋子连接数量
    //xChange--》列变，yChange--》行变，color--》棋子颜色
    private int checkCount(int xChange, int yChange, int color) {
        int count = 1;
        int tempx = xChange;
        int tempy = yChange;
        while (x + xChange >= 0 && x + xChange <= 18
                && y + yChange >= 0 && y + yChange <= 18
                && color == allChess[y + yChange][x + xChange]) {
            count++;
            if (xChange != 0) {//列
                if (xChange > 0) {
                    xChange++;
                }
                if (xChange < 0) {//行
                    xChange--;
                }
            }
            if (yChange != 0) {
                yChange++;
            }
        }
        xChange = tempx;
        yChange = tempy;
        while (x - xChange >= 0 && x - xChange <= 18
                && y - yChange >= 0 && y - yChange <= 18
                && color == allChess[y - yChange][x - xChange]) {
            count++;
            if (xChange != 0) {//列
                if (xChange > 0) {
                    xChange++;
                }
                if (xChange < 0) {//行
                    xChange--;
                }
            }
            if (yChange != 0) {
                yChange++;
            }
        }
        return count;
    }
```

### 6.4 判断五子棋输赢（第二种）

```java
//判断游戏输赢
private boolean checkWin() {
    //判断输赢的变量
    boolean flag = false;

//判断横向是否有5个棋子相连
    //特点：纵坐标是相同的,即行号相同
    int color = allChess[y][x];
    //保存共有相同颜色多少个棋子相连
    int count1 = 1;
    //通过循环判断棋子相连个数
    int i1 = 1;
    while (color == allChess[y][x + i1]) {
        count1++;
        i1++;
    }
    i1 = 1;
    while (color == allChess[y][x - i1]) {
        count1++;
        i1++;
    }

if (count1 >= 5) {
        flag = true;
        return flag;//提前返回boolean值，终止游戏
    }

//判断纵向是否有5个棋子相连
    //特点：横坐标是相同的,即列号相同
    //通过循环判断棋子相连个数
    int i2 = 1;
    int count2 = 1;
    while (color == allChess[y + i2][x]) {
        count2++;
        i2++;
    }
    i2 = 1;
    while (color == allChess[y - i2][x]) {
        count2++;
        i2++;
    }

if (count2 >= 5) {
        flag = true;
        return flag;//提前返回boolean值，终止游戏
    }

//斜方向的判断：右上+左下
    //特点：行增加，列减少
    int i3 = 1;
    int count3 = 1;
    while (color == allChess[y + i3][x - i3]) {
        count3++;
        i3++;
    }
    i3 = 1;
    while (color == allChess[y - i3][x + i3]) {
        count3++;
        i3++;
    }

if (count3 >= 5) {
        flag = true;
        return flag;//提前返回boolean值，终止游戏
    }

//斜方向的判断：左上+右下
    //特点：行增加，列增加
    int i4 = 1;
    int count4 = 1;
    while (color == allChess[y + i4][x + i4]) {
        count4++;
        i4++;
    }
    i4 = 1;
    while (color == allChess[y - i4][x - i4]) {
        count4++;
        i4++;
    }

if (count4 >= 5) {
        flag = true;
        return flag;//提前返回boolean值，终止游戏
    }
   return flag;
}
```

### 6.5 6个按钮的实现

- 这六个按钮可以分别写方法，这样好看一些

```java
	//保存显示的提示信息
    String message = "黑方先行";

//保存最多用有多少时间(秒)
    int maxTime = 0;

//做倒计时的线程类
    Thread t = new Thread(this);
    //保存黑方与白方的剩余时间
    int blackTime = 0;
    int whiteTime = 0;
    //保存双方剩余时间的显示信息
    String blackMessage = "无限制";
    String whiteMessage = "无限制";

@Override
public void mousePressed(MouseEvent e) {//监听鼠标按下事件的操作
    if (canPlay == true) {
       //...省略棋盘的棋子的操作...
    }

//点击【开始游戏】按钮--》重新开始游戏
    if (e.getX() >= 400 && e.getX() <= 470 && e.getY() >= 70 && e.getY() <= 100) {
        //显示一个消息对话框，会有三个选项
        int result = JOptionPane.showConfirmDialog(this, "是否重新开始游戏？");

if (result == 0) {//是
            //现在重新开始游戏
            //清空棋盘
            for (int i = 0; i < 19; ++i) {
                for (int j = 0; j < 19; ++j) {
                    allChess[i][j] = 0;
                }
            }
            //将游戏信息改回到开始状态
            canPlay = true;
            message = "黑方先行";
            //将下一步下棋的改为黑方
            isBlack = true;

blackTime = maxTime;
            whiteTime = maxTime;
            if (maxTime > 0) {
                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();
            } else {
                blackMessage = "无限制";
                whiteMessage = "无限制";
            }

//刷新界面
            this.repaint();
        }

}

//点击【游戏设置】按钮--》设置倒计时时间
    if (e.getX() >= 400 && e.getX() <= 470 && e.getY() >= 120 && e.getY() <= 150) {
        //显示一个可输入的对话框，返回一个String类型的值
        String input = JOptionPane.showInputDialog("请输入游戏的最大时间：(分钟)\n" +
                "如果输入的是：0，表示没有时间限制");

//将String转换为int类型
        try {
            maxTime = Integer.parseInt(input) * 60;
            if (maxTime < 0) {
                JOptionPane.showMessageDialog(this, "请输入正确信息！！！\n" +
                        "不允许输入负数！");
            } else if (maxTime == 0) {
                int result = JOptionPane.showConfirmDialog(this, "输入完成！！！\n" +
                        "是否重新开始游戏？");

if (result == 0) {//是
                    //现在重新开始游戏
                    //清空棋盘
                    for (int i = 0; i < 19; ++i) {
                        for (int j = 0; j < 19; ++j) {
                            allChess[i][j] = 0;
                        }
                    }
                    //将游戏信息改回到开始状态
                    canPlay = true;
                    message = "黑方先行";
                    //将下一步下棋的改为黑方
                    isBlack = true;

blackTime = maxTime;
                    whiteTime = maxTime;

//刷新界面
                    this.repaint();
                }
            } else if (maxTime > 0) {
                int result = JOptionPane.showConfirmDialog(this, "输入完成！！！\n" +
                        "是否重新开始游戏？");

if (result == 0) {//是
                    //现在重新开始游戏
                    //清空棋盘
                    for (int i = 0; i < 19; ++i) {
                        for (int j = 0; j < 19; ++j) {
                            allChess[i][j] = 0;
                        }
                    }
                    //将游戏信息改回到开始状态
                    canPlay = true;
                    message = "黑方先行";
                    //将下一步下棋的改为黑方
                    isBlack = true;

blackTime = maxTime;
                    whiteTime = maxTime;

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.repaint();
                }
            }
        } catch (NumberFormatException ex) {
            JOptionPane.showMessageDialog(this, "请正确输入信息！！！");
        }
    }

//点击【游戏说明】按钮--》用来说明游戏规则和操作
    if (e.getX() >= 400 && e.getX() <= 470 && e.getY() >= 170 && e.getY() <= 200) {
        //提示信息
        JOptionPane.showMessageDialog(this, "游戏说明：\n" +
                "这是一个五子棋游戏程序，黑白双方轮流下棋，当某一方连到五子时，游戏结束。");
    }

//点击【认输】按钮--》表示某一方放弃游戏，投子认输
    if (e.getX() >= 400 && e.getX() <= 470 && e.getY() >= 270 && e.getY() <= 300) {
        //显示一个消息对话框，会有三个选项
        int result = JOptionPane.showConfirmDialog(this, "是否确认认输？");

if (result == 0) {//是
            String name = null;
            if (isBlack == true) {
                name = "黑方";
            } else {
                name = "白方";
            }
            JOptionPane.showMessageDialog(this, "【" + name + "】认输，游戏结束");
            canPlay = false;
        }
    }

//点击【关于】按钮--》游戏作者和公司单位信息
    if (e.getX() >= 400 && e.getX() <= 470 && e.getY() >= 320 && e.getY() <= 350) {
        //提示信息
        JOptionPane.showMessageDialog(this, "关于：\n" +
                "本游戏制作纯属娱乐\n" + "作者：冥冥之中立刻有\n" + "QQ群：290397456");
    }

//点击【退出】按钮--》结束程序
    if (e.getX() >= 400 && e.getX() <= 470 && e.getY() >= 370 && e.getY() <= 400) {
        //提示信息
        JOptionPane.showMessageDialog(this, "游戏结束");
        System.exit(0);
    }
}
```

### 6.6 重写run()方法

```java
@Override
public void run() {
    //判断是否有时间限制
    if (maxTime > 0) {
        while (true) {
            if (isBlack) {
                blackTime--;
                if (blackTime == 0) {
                    JOptionPane.showMessageDialog(this, "【黑方】超时，游戏结束！");
                }
            } else {
                whiteTime--;
                if (whiteTime == 0) {
                    JOptionPane.showMessageDialog(this, "【白方】超时，游戏结束！");
                }
            }
            //休眠一秒钟
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            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();
            //System.out.println(blackTime + "----" + whiteTime);
        }
    }
}
```

## 7. 成果展示

![](/image_editor_upload/20200411073221_88938.png)

0.0分

8 人评分

看不懂代码解释一下代码? 或者生成一段代码？试试AI编程助手吧

　　评论区

编程细胞

代码运行视频:https://b23.tv/BV1JV411o7FD

2020-04-11 19:54:40

编程细胞

TA的其他文章

你可能喜欢

C语言程序设计教程（第三版）课后习题3.7 （C语言代码）

A+B for Input-Output Practice (VII) （C++代码）

【数组的距离】（C语言代码）

C二级辅导-求偶数和（C语言代码）

假币问题（C++代码）（向上取整的一种处理方式）

Java小游戏之五子棋

评论区

精彩推荐

C语言程序设计教程（第三版）课后习题5.7 （C语言代码）

矩阵转置（C语言代码）

2004年秋浙江省计算机等级考试二级C 编程题(1) （C语言代码）

C语言程序设计教程（第三版）课后习题9.2 （Java代码）

上车人数（C语言代码）

C语言程序设计教程（第三版）课后习题8.1 （C语言代码）

printf基础练习2 （C语言代码）

IP判断（C语言代码）

母牛的故事（C语言代码）

C语言程序设计教程（第三版）课后习题10.1 （C语言代码）

编程细胞

TA的其他文章

你可能喜欢

C语言程序设计教程（第三版）课后习题3.7 （C语言代码）

A+B for Input-Output Practice (VII) （C++代码）

【数组的距离】 （C语言代码）

C二级辅导-求偶数和 （C语言代码）

假币问题 （C++代码）（向上取整的一种处理方式）

Java小游戏之五子棋

评论区

精彩推荐

C语言程序设计教程（第三版）课后习题5.7 （C语言代码）

矩阵转置 （C语言代码）

2004年秋浙江省计算机等级考试二级C 编程题(1) （C语言代码）

C语言程序设计教程（第三版）课后习题9.2 （Java代码）

上车人数 （C语言代码）

C语言程序设计教程（第三版）课后习题8.1 （C语言代码）

printf基础练习2 （C语言代码）

IP判断 （C语言代码）

母牛的故事 （C语言代码）

C语言程序设计教程（第三版）课后习题10.1 （C语言代码）

【数组的距离】（C语言代码）

C二级辅导-求偶数和（C语言代码）

假币问题（C++代码）（向上取整的一种处理方式）

　　评论区

矩阵转置（C语言代码）

上车人数（C语言代码）

IP判断（C语言代码）

母牛的故事（C语言代码）