教程：从0到1手把手制作一个java五子棋小应用（超详细）

已于 2024-07-23 14:37:07 修改
阅读量898 收藏 25
点赞数 12
文章标签： java 开发语言
于 2024-07-23 11:56:34 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_65018431/article/details/140626412
版权

目录

前言：

1.画出完整的五子棋棋盘界面

1.我们首先定义两个类

2.程序的详细运行步骤

3.绘制棋盘思路

2.绘制出每次点击棋盘时的黑白棋子

1.绘制棋子思路

3.判断每次黑白棋子落下之后游戏是否结束

4.完整三个类详细注释代码：

5.编译.class和打jar包方式

前言：

在本次教程中，我将尽可能的减少非必要的代码，防止一上来就是铺天盖地的代码直面眼前，这个五子棋app仅在java基础知识上，用到了awt和swing库，并无其他高阶知识，当涉及到swing库的使用时，我将会配以非常详细的注释辅助说明，以便初学者理解，我也会把一个完整的五子棋app的实现分为3个阶段来讲解：

1.画出完整的五子棋棋盘界面

2.能够绘制出每次点击棋盘时的黑白棋子

3.判断每次黑白棋子落下之后游戏是否结束

后一个阶段的功能都是在前一个阶段上面添加代码实现的，并不修改之前的代码，源码会放在最后。

运行图：

1.画出完整的五子棋棋盘界面

1.我们首先定义两个类

其中ChessJFrame 类是程序入口，包含主函数，创建并显示主窗口，包含一个 ChessBoard 对象作为棋盘。

ChessBoard 类绘制棋盘格子，并处理鼠标点击事件（第二阶段会用到）。

2.程序的详细运行步骤

// 我来描述一下程序的执行步骤：

// 首先程序执行main函数。
// 在main函数中，创建一个ChessJFrame对象，这会调用ChessJFrame的构造方法。

// 在构造方法中，首先定义一个 ChessBoard 类型的变量 `chessBoard` 并初始化它。
// 执行 setTitle("简单五子棋"); // 设置窗口标题为 "简单五子棋"

// 执行 chessBoard = new ChessBoard(); // 创建一个新的 ChessBoard 对象
// 在这个时候会执行ChessBoard类的静态变量定义和构造方法。
// 这些静态变量定义如下：
// public static final int MARGIN = 30; // 定义边距
// public static final int ROWS = 15; // 定义行数
// public static final int COLS = 15; // 定义列数
// public static final int GRID_SPAN = 35; // 网格间距

// 然后执行ChessBoard类的构造方法：
// public ChessBoard() {
//     setBackground(Color.LIGHT_GRAY); // 设置背景颜色为浅灰色
//     // 后续我们在这里还是要加监听鼠标功能的
// }

// 接着，执行 add(chessBoard); // 将 ChessBoard 对象添加到 JFrame 中
// 调用 add(chessBoard) 方法将 chessBoard 组件添加到 ChessJFrame 的内容面板中。
// 这个操作会触发一系列步骤和方法调用，以确保组件正确地添加并显示在用户界面中。
// 添加新组件后，容器需要重绘自己以显示新添加的组件。repaint() 方法会被调用，它会安排一次重绘事件以更新用户界面。
// 这一步会导致调用组件的 paintComponent(Graphics g) 方法，以实际绘制组件的内容。
// 也会调用 public Dimension getPreferredSize() 方法用于确定窗口的大小。

// 其实绘制棋盘的大体思路也很简单，是根据两点确定一条直线来绘制的，根据格子的大小和行数和确定重点。

// 绘制好棋盘之后，依次执行一些修饰代码：
// setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); // 设置窗口关闭操作为退出程序
// pack(); // 根据其内容调整窗口的大小

// 回到main函数，继续执行以下步骤：
// frame.setLocationRelativeTo(null); // 将窗口居中显示
// frame.setVisible(true); // 设置窗口为可见

// 这样就结束了程序的初始化，并显示窗口和棋盘。

3.绘制棋盘思路

绘制的棋盘就是重复绘制直线，绘制直线的方法是

从起点坐标到终点坐标，使用 drawLine 方法绘制从 (MARGIN, MARGIN + i * GRID_SPAN) 到 (MARGIN + COLS * GRID_SPAN, MARGIN + i * GRID_SPAN) 的横线

两个类的源码附详细注释如下

import javax.swing.*; // 导入用于构建图形界面的Swing库

//ChessJFrame 类继承自 JFrame，用于创建一个带有 Swing 窗口功能的自定义类。
public class ChessJFrame extends JFrame {
    // 定义一个 ChessBoard 类型的变量，表示棋盘
    private ChessBoard chessBoard;

    // 构造方法，用于初始化 ChessJFrame 对象
    public ChessJFrame() {
        setTitle("简单五子棋"); // 设置窗口标题为 "简单五子棋"
        chessBoard = new ChessBoard(); // 创建一个新的 ChessBoard 对象
        add(chessBoard); // 将 ChessBoard 对象添加到 JFrame 中
        setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); // 设置窗口关闭操作为退出程序
        pack(); // 根据其内容调整窗口的大小
    }

    // 程序的入口点
    public static void main(String[] args) {
        ChessJFrame frame = new ChessJFrame(); // 创建一个 ChessJFrame 对象
        frame.setLocationRelativeTo(null); // 将窗口居中显示
        frame.setVisible(true); // 设置窗口为可见
    }
}
import java.awt.*; // 导入用于图形界面相关的类
import javax.swing.*; // 导入用于构建图形界面的Swing库

// `ChessBoard` 类继承自 `JPanel`，用于创建一个自定义的面板组件，可以在其中绘制棋盘。
public class ChessBoard extends JPanel {
    // 定义常量，用于设置棋盘的边距、行数、列数和网格间距
    public static final int MARGIN = 30; // 定义棋盘边距
    public static final int ROWS = 15; // 定义棋盘行数
    public static final int COLS = 15; // 定义棋盘列数
    public static final int GRID_SPAN = 35; // 定义网格间距

    // 构造方法，用于初始化 ChessBoard 对象
    public ChessBoard() {
        // 设置棋盘的背景颜色为浅灰色
        setBackground(Color.LIGHT_GRAY);
        // 后续我们在这里还要加监听鼠标功能的
    }

    // 重写 JPanel 类的 paintComponent 方法，用于自定义绘制组件的内容
    @Override
    protected void paintComponent(Graphics g) {
        // 调用父类的 paintComponent 方法，以确保组件正确绘制
        super.paintComponent(g);
        // 绘制棋盘的横线
        for (int i = 0; i <= ROWS; i++) {
            // 从起点坐标到终点坐标，使用 drawLine 方法绘制从 (MARGIN, MARGIN + i * GRID_SPAN) 到 (MARGIN + COLS * GRID_SPAN, MARGIN + i * GRID_SPAN) 的横线
            g.drawLine(MARGIN, MARGIN + i * GRID_SPAN, MARGIN + COLS * GRID_SPAN, MARGIN + i * GRID_SPAN);
        }
        // 绘制棋盘的竖线
        for (int j = 0; j <= COLS; j++) {
            // 使用 drawLine 方法绘制从 (MARGIN + j * GRID_SPAN, MARGIN) 到 (MARGIN + j * GRID_SPAN, MARGIN + ROWS * GRID_SPAN) 的竖线
            g.drawLine(MARGIN + j * GRID_SPAN, MARGIN, MARGIN + j * GRID_SPAN, MARGIN + ROWS * GRID_SPAN);
        }
    }

    // 重写 JPanel 类的 getPreferredSize 方法，用于提供组件的首选大小
    @Override
    public Dimension getPreferredSize() {
        // 返回一个 Dimension 对象，表示棋盘的首选大小，包括边距和网格间距
        return new Dimension(MARGIN * 2 + GRID_SPAN * COLS, MARGIN * 2 + GRID_SPAN * ROWS);
    }
}

点击ChessJFrame类中的main函数运行，我们就能得到一个空棋盘

2.绘制出每次点击棋盘时的黑白棋子

要绘制棋子，我们得首先定义一个棋子类（Chess）

代码如下：

import java.awt.Color; // 导入用于处理颜色的类

// 定义一个 Chess 类，用于表示棋子
public class Chess {
    // 私有变量，表示棋子的x坐标索引
    private int x; 
    // 私有变量，表示棋子的y坐标索引
    private int y; 
    // 私有变量，表示棋子的颜色
    private Color color; 

    // 定义一个常量，表示棋子的直径
    public static final int DIAMETER = 30; 

    // 构造方法，用于初始化 Chess 对象
    public Chess(int x, int y, Color color) {
        // 初始化 x 坐标索引
        this.x = x;
        // 初始化 y 坐标索引
        this.y = y;
        // 初始化棋子的颜色
        this.color = color;
    }

    // 公共方法，获取棋子的 x 坐标索引
    public int getX() {
        return x;
    }

    // 公共方法，获取棋子的 y 坐标索引
    public int getY() {
        return y;
    }

    // 公共方法，获取棋子的颜色
    public Color getColor() {
        return color;
    }
}

1.绘制棋子思路

如何在鼠标点击的地方绘制出一个棋子呢？我们的思路是创建一个数组，当我们点击棋盘时，我们记录此时这个位置的的xy坐标，把棋子记录到数组中，改变下一次棋子的颜色，重新绘制棋盘，画出之前和新添的棋子。

要记录点击棋盘的行为，我们需要一个监听器，要改变颜色我们需要一个变量来确定颜色，并且在每次点击后改变自身的值，点击完成之后，我们要重新绘制棋盘以及根据存放棋子的数组里的信息绘制棋子，要是实现这些功能，导入需要的类或包
新增的代码有：

导入包和类

import java.awt.*; // 导入用于图形界面相关的类
import java.awt.event.*; // 导入用于事件处理的类
import java.util.ArrayList; // 导入用于动态数组的类
import javax.swing.*; // 导入用于构建图形界面的Swing库

在定义变量时添加

  private ArrayList<Chess> chessList = new ArrayList<>(); // 存储棋子的列表
  private boolean isBlackTurn = true; // 记录当前是否为黑棋回合

在初始化 ChessBoard 对象时加入监听器，并检查点击操作是否合法

// 添加鼠标监听器，以便处理鼠标点击事件
        addMouseListener(new MouseAdapter() {
            @Override
            public void mousePressed(MouseEvent e) {
                // 将鼠标点击位置转换为棋盘坐标
                int x = (e.getX() - MARGIN + GRID_SPAN / 2) / GRID_SPAN;
                int y = (e.getY() - MARGIN + GRID_SPAN / 2) / GRID_SPAN;

                // 检查点击的位置是否在棋盘范围内
                if (x < 0 || x >= COLS || y < 0 || y >= ROWS) return;

                // 检查是否已有棋子在此位置
                for (Chess c : chessList) {
                    if (c.getX() == x && c.getY() == y) return;
                }

                // 创建新的棋子并添加到列表中
                Color color = isBlackTurn ? Color.BLACK : Color.WHITE;
                chessList.add(new Chess(x, y, color));

                // 切换回合
                isBlackTurn = !isBlackTurn;

                // 重新绘制棋盘
                repaint();
            }
        });

在paintComponent(Graphics g) 函数中，绘制完棋盘之后加入画棋子的代码

  // 画棋子
        for (Chess c : chessList) {
            // 计算棋子在棋盘上的像素位置
            int xPos = MARGIN + c.getX() * GRID_SPAN;
            int yPos = MARGIN + c.getY() * GRID_SPAN;
            g.setColor(c.getColor()); // 设置棋子的颜色
            // 绘制棋子
            g.fillOval(xPos - Chess.DIAMETER / 2, yPos - Chess.DIAMETER / 2, Chess.DIAMETER, Chess.DIAMETER);
        }

修改后的ChessBoard的完整代码（ChessJframe的代码控制运行大体逻辑并不需要更改）

import java.awt.*; // 导入用于图形界面相关的类
import java.awt.event.*; // 导入用于事件处理的类
import java.util.ArrayList; // 导入用于动态数组的类
import javax.swing.*; // 导入用于构建图形界面的Swing库

// `ChessBoard` 类继承自 `JPanel`，用于创建一个自定义的面板组件，可以在其中绘制棋盘和处理用户的交互。
public class ChessBoard extends JPanel {
    // 定义常量，用于设置棋盘的边距、行数、列数和网格间距
    public static final int MARGIN = 30; // 定义边距
    public static final int ROWS = 15; // 定义行数
    public static final int COLS = 15; // 定义列数
    public static final int GRID_SPAN = 35; // 网格间距

    private ArrayList<Chess> chessList = new ArrayList<>(); // 存储棋子的列表
    private boolean isBlackTurn = true; // 记录当前是否为黑棋回合

    // 构造方法，用于初始化 ChessBoard 对象
    public ChessBoard() {
        setBackground(Color.LIGHT_GRAY); // 设置棋盘的背景颜色为浅灰色
        // 添加鼠标监听器，以便处理鼠标点击事件
        addMouseListener(new MouseAdapter() {
            @Override
            public void mousePressed(MouseEvent e) {
                // 将鼠标点击位置转换为棋盘坐标
                int x = (e.getX() - MARGIN + GRID_SPAN / 2) / GRID_SPAN;
                int y = (e.getY() - MARGIN + GRID_SPAN / 2) / GRID_SPAN;

                // 检查点击的位置是否在棋盘范围内
                if (x < 0 || x >= COLS || y < 0 || y >= ROWS) return;

                // 检查是否已有棋子在此位置
                for (Chess c : chessList) {
                    if (c.getX() == x && c.getY() == y) return;
                }

                // 创建新的棋子并添加到列表中
                Color color = isBlackTurn ? Color.BLACK : Color.WHITE;
                chessList.add(new Chess(x, y, color));

                // 切换回合
                isBlackTurn = !isBlackTurn;

                // 重新绘制棋盘
                repaint();
            }
        });
    }

    // 重写 JPanel 类的 paintComponent 方法，用于自定义绘制组件的内容
    @Override
    protected void paintComponent(Graphics g) {
        super.paintComponent(g);
        // 画棋盘的横线
        for (int i = 0; i <= ROWS; i++) {
            g.drawLine(MARGIN, MARGIN + i * GRID_SPAN, MARGIN + COLS * GRID_SPAN, MARGIN + i * GRID_SPAN); // 画横线
        }
        // 画棋盘的竖线
        for (int j = 0; j <= COLS; j++) {
            g.drawLine(MARGIN + j * GRID_SPAN, MARGIN, MARGIN + j * GRID_SPAN, MARGIN + ROWS * GRID_SPAN); // 画竖线
        }
        // 画棋子
        for (Chess c : chessList) {
            // 计算棋子在棋盘上的像素位置
            int xPos = MARGIN + c.getX() * GRID_SPAN;
            int yPos = MARGIN + c.getY() * GRID_SPAN;
            g.setColor(c.getColor()); // 设置棋子的颜色
            // 绘制棋子
            g.fillOval(xPos - Chess.DIAMETER / 2, yPos - Chess.DIAMETER / 2, Chess.DIAMETER, Chess.DIAMETER);
        }
    }

    // 重写 JPanel 类的 getPreferredSize 方法，用于提供组件的首选大小
    @Override
    public Dimension getPreferredSize() {
        // 返回一个 Dimension 对象，表示棋盘的首选大小，包括边距和网格间距
        return new Dimension(MARGIN * 2 + GRID_SPAN * COLS, MARGIN * 2 + GRID_SPAN * ROWS);
    }
}

3.判断每次黑白棋子落下之后游戏是否结束

要实现这个功能我们需要一个判断函数checkWin()，以及一些辅助函数用于判断函数内，在每次新增落子绘图之后进行判断

注意检查时会在正方两个方向进行检查，正方向2个棋子，反方向2个棋子，加上自身5个棋子也是完成胜利判断的

新增的代码如下：

函数：

// 检查是否在给定位置(x, y)和给定颜色的棋子形成五连珠
private boolean checkWin(int x, int y, Color color) {
    // 检查四个方向：水平、垂直、正斜和反斜
    return checkDirection(x, y, color, 1, 0) // 水平方向
            || checkDirection(x, y, color, 0, 1) // 垂直方向
            || checkDirection(x, y, color, 1, 1) // 正斜方向
            || checkDirection(x, y, color, 1, -1); // 反斜方向
}

// 检查给定方向(dx, dy)上是否形成五连珠
private boolean checkDirection(int x, int y, Color color, int dx, int dy) {
    int count = 1; // 初始化计数器，包含当前位置的棋子
    int i = 1;

    // 检查正方向，dx和dy为正数时，向右下方向检查
    while (isValid(x + i * dx, y + i * dy) // 检查坐标是否有效
            && getColor(x + i * dx, y + i * dy) == color) { // 检查棋子颜色是否匹配
        count++; // 计数器加1
        i++; // 继续检查下一个位置
    }

    // 检查反方向，dx和dy为负数时，向左上方向检查
    i = 1; // 重置i
    while (isValid(x - i * dx, y - i * dy) // 检查坐标是否有效
            && getColor(x - i * dx, y - i * dy) == color) { // 检查棋子颜色是否匹配
        count++; // 计数器加1
        i++; // 继续检查下一个位置
    }

    // 如果在给定方向上总共有5个或更多连续的同色棋子，则返回true
    return count >= 5;
}

// 检查给定坐标(x, y)是否在棋盘范围内
private boolean isValid(int x, int y) {
    // x和y必须在0到COLS和ROWS之间
    return x >= 0 && x < COLS && y >= 0 && y < ROWS;
}

// 获取给定坐标(x, y)处的棋子的颜色
private Color getColor(int x, int y) {
    // 遍历所有棋子，找到与给定坐标匹配的棋子
    for (Chess c : chessList) {
        // 如果找到棋子，返回其颜色
        if (c.getX() == x && c.getY() == y) {
            return c.getColor();
        }
    }
    // 如果没有找到匹配的棋子，返回null
    return null;
}

在绘制repaint();函数后加入的判断：

 // 检查是否胜利
                if (checkWin(x, y, color)) {
                    JOptionPane.showMessageDialog(ChessBoard.this, (color == Color.BLACK ? "黑棋" : "白棋") + "胜利！");
                    chessList.clear(); // 清空棋盘，重新开始
                    repaint();
                } else {
                    // 切换回合
                    isBlackTurn = !isBlackTurn;
                }

那通过我们的函数更新我们就已经完成我们的判断操作，通过新建函数的方式去更新加入功能是一种很不错的思维方式。

4.完整三个类详细注释代码：

Chess:

import java.awt.*;

// `Chess` 类表示棋子，包含棋子的坐标和颜色信息
public class Chess {
    private int x; // 棋子的x坐标索引，表示在棋盘中的列
    private int y; // 棋子的y坐标索引，表示在棋盘中的行
    private Color color; // 棋子的颜色，使用 `Color` 类表示

    public static final int DIAMETER = 30; // 棋子的直径，定义为常量

    // 构造方法，用于初始化 `Chess` 对象
    public Chess(int x, int y, Color color) {
        this.x = x; // 设置棋子的x坐标
        this.y = y; // 设置棋子的y坐标
        this.color = color; // 设置棋子的颜色
    }

    // 获取棋子的x坐标
    public int getX() {
        return x;
    }

    // 获取棋子的y坐标
    public int getY() {
        return y;
    }

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

ChessBoard:

import java.awt.*; // 导入用于图形界面相关的类
import java.awt.event.*; // 导入用于事件处理相关的类
import java.util.ArrayList; // 导入用于处理数组列表的类
import javax.swing.*; // 导入用于构建图形界面的Swing库

// `ChessBoard` 类继承自 `JPanel`，用于创建一个自定义的面板组件，可以在其中绘制棋盘和处理棋子放置逻辑
public class ChessBoard extends JPanel {
    public static final int MARGIN = 30; // 定义棋盘边距
    public static final int ROWS = 15; // 定义棋盘行数
    public static final int COLS = 15; // 定义棋盘列数
    public static final int GRID_SPAN = 35; // 定义棋盘网格间距

    private ArrayList<Chess> chessList = new ArrayList<>(); // 存储棋子的列表
    private boolean isBlackTurn = true; // 记录当前是否为黑棋回合

    // 构造方法，用于初始化 `ChessBoard` 对象
    public ChessBoard() {
        setBackground(Color.LIGHT_GRAY); // 设置棋盘背景颜色为浅灰色
        // 添加鼠标事件监听器，处理鼠标点击事件
        addMouseListener(new MouseAdapter() {
            @Override
            public void mousePressed(MouseEvent e) {
                // 将鼠标点击位置转换为棋盘坐标
                int x = (e.getX() - MARGIN + GRID_SPAN / 2) / GRID_SPAN;
                int y = (e.getY() - MARGIN + GRID_SPAN / 2) / GRID_SPAN;

                // 检查点击的位置是否在棋盘范围内
                if (x < 0 || x >= COLS || y < 0 || y >= ROWS) return;

                // 检查是否已有棋子在此位置
                for (Chess c : chessList) {
                    if (c.getX() == x && c.getY() == y) return;
                }

                // 创建新的棋子并添加到列表中
                Color color = isBlackTurn ? Color.BLACK : Color.WHITE;
                chessList.add(new Chess(x, y, color));

                // 重新绘制棋盘
                repaint();

                // 检查是否胜利
                if (checkWin(x, y, color)) {
                    JOptionPane.showMessageDialog(ChessBoard.this, (color == Color.BLACK ? "黑棋" : "白棋") + "胜利！");
                    chessList.clear(); // 清空棋盘，重新开始
                    repaint();
                } else {
                    // 切换回合
                    isBlackTurn = !isBlackTurn;
                }
            }
        });
    }

    // 重写 `paintComponent` 方法，用于自定义绘制组件的内容
    @Override
    protected void paintComponent(Graphics g) {
        super.paintComponent(g);
        // 画棋盘的横线
        for (int i = 0; i <= ROWS; i++) {
            g.drawLine(MARGIN, MARGIN + i * GRID_SPAN, MARGIN + COLS * GRID_SPAN, MARGIN + i * GRID_SPAN);
        }
        // 画棋盘的竖线
        for (int j = 0; j <= COLS; j++) {
            g.drawLine(MARGIN + j * GRID_SPAN, MARGIN, MARGIN + j * GRID_SPAN, MARGIN + ROWS * GRID_SPAN);
        }
        // 画棋子
        for (Chess c : chessList) {
            int xPos = MARGIN + c.getX() * GRID_SPAN;
            int yPos = MARGIN + c.getY() * GRID_SPAN;
            g.setColor(c.getColor());
            g.fillOval(xPos - Chess.DIAMETER / 2, yPos - Chess.DIAMETER / 2, Chess.DIAMETER, Chess.DIAMETER);
        }
    }

    // 重写 `getPreferredSize` 方法，用于提供组件的首选大小
    @Override
    public Dimension getPreferredSize() {
        return new Dimension(MARGIN * 2 + GRID_SPAN * COLS, MARGIN * 2 + GRID_SPAN * ROWS);
    }

    // 检查是否在给定位置 (x, y) 和给定颜色的棋子形成五连珠
    private boolean checkWin(int x, int y, Color color) {
        return checkDirection(x, y, color, 1, 0) // 水平
                || checkDirection(x, y, color, 0, 1) // 垂直
                || checkDirection(x, y, color, 1, 1) // 正斜
                || checkDirection(x, y, color, 1, -1); // 反斜
    }

    // 检查给定方向 (dx, dy) 上是否形成五连珠
    private boolean checkDirection(int x, int y, Color color, int dx, int dy) {
        int count = 1; // 初始化计数器，包含当前位置的棋子
        int i = 1;

        // 检查正方向，dx 和 dy 为正数时，向右下方向检查
        while (isValid(x + i * dx, y + i * dy) // 检查坐标是否有效
                && getColor(x + i * dx, y + i * dy) == color) { // 检查棋子颜色是否匹配
            count++; // 计数器加1
            i++; // 继续检查下一个位置
        }

        // 检查反方向，dx 和 dy 为负数时，向左上方向检查
        i = 1; // 重置 i
        while (isValid(x - i * dx, y - i * dy) // 检查坐标是否有效
                && getColor(x - i * dx, y - i * dy) == color) { // 检查棋子颜色是否匹配
            count++; // 计数器加1
            i++; // 继续检查下一个位置
        }

        // 如果在给定方向上总共有 5 个或更多连续的同色棋子，则返回 true
        return count >= 5;
    }

    // 检查给定坐标 (x, y) 是否在棋盘范围内
    private boolean isValid(int x, int y) {
        // x 和 y 必须在 0 到 COLS 和 ROWS 之间
        return x >= 0 && x < COLS && y >= 0 && y < ROWS;
    }

    // 获取给定坐标 (x, y) 处的棋子的颜色
    private Color getColor(int x, int y) {
        // 遍历所有棋子，找到与给定坐标匹配的棋子
        for (Chess c : chessList) {
            // 如果找到棋子，返回其颜色
            if (c.getX() == x && c.getY() == y) {
                return c.getColor();
            }
        }
        // 如果没有找到匹配的棋子，返回 null
        return null;
    }
}

ChessJFrame:

import javax.swing.*; // 导入Swing库中的类，用于构建图形用户界面

// `ChessJFrame` 类继承自 `JFrame`，用于创建应用程序的主窗口
public class ChessJFrame extends JFrame {
    private ChessBoard chessBoard; // 定义一个 `ChessBoard` 类型的变量，用于表示棋盘

    // 构造方法，用于初始化 `ChessJFrame` 对象
    public ChessJFrame() {
        setTitle("简单五子棋"); // 设置窗口的标题为 "简单五子棋"

        chessBoard = new ChessBoard(); // 创建一个新的 `ChessBoard` 对象

        add(chessBoard); // 将 `ChessBoard` 对象添加到 `JFrame` 的内容面板中

        setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); // 设置窗口关闭操作为退出程序

        pack(); // 调整窗口的大小以适应其内容
    }

    // 程序的入口点
    public static void main(String[] args) {
        ChessJFrame frame = new ChessJFrame(); // 创建一个 `ChessJFrame` 对象

        frame.setLocationRelativeTo(null); // 将窗口居中显示

        frame.setVisible(true); // 设置窗口为可见
    }
}

5.编译.class和打jar包方式

1)编译 .java 文件成 .class 文件

  1. 打开项目: 在 IntelliJ IDEA 中打开你的 Java 项目。
  2. 配置 JDK:

确保已为项目配置了 JDK。可以通过 File -> Project Structure -> Project 确认和设置。

  1. 编写代码: 确保你的 .java 文件在 src 目录中。
  2. 编译项目:

在菜单栏中，选择 Build -> Build Project 或使用快捷键 Ctrl+F9（Windows/Linux）或 Cmd+F9（Mac）。

IntelliJ IDEA 将编译 .java 文件并生成 .class 文件，通常存放在 out 或 target 目录中（取决于项目配置）。

2) 打包成 JAR 包

  1. 配置 Artifacts:

打开 File -> Project Structure。

选择 Artifacts 标签。

点击左上角的 + 号，选择 JAR -> From modules with dependencies。

选择你的主模块，确保将生成的 .class 文件和所需的依赖项包含在内。

设置输出目录。

  1. 生成 JAR 包:

配置完成后，点击 Apply 和 OK。

在菜单栏中，选择 Build -> Build Artifacts。

在弹出的菜单中选择你刚刚配置的 JAR 项目，点击 Build。

IntelliJ IDEA 将编译并打包你的项目，生成 JAR 文件在你指定的输出目录中。

最后的生成目录如下：

​​​​​​​

我要学c加加！
关注
  • 12
    点赞
  • 踩
  • 25
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值