五子棋———完美注释版，免费分享！！！

这是一个基于穷举算法的五子棋。人机大战时，计算机的算法是扫描穷举法。下面是核心类的代码。

import javax.swing.JOptionPane;
import javax.swing.JPanel;

//五子棋游戏的核心类
public class GoGame {
// 棋盘的高度，宽度。chessModel代表棋盘的种类1为20*15，2为30*20，3为40*30
private int height, width, chessModel;
// 棋盘的横纵坐标，用于获取点击坐标的,初始化的值为零。
private int x = 0, y = 0;
// 棋盘对应的颜色，取1，2，3，-5。
// 1代表棋盘格上为黑子，2代表棋盘格上位白子，3代表棋盘格上没有棋子，-5代表棋盘格上不能下子//包括了边
private int[][] chessMapShow;
// isOdd交换棋手的标志，true是黑子（玩家）下，false是白子下,但是下完子之后，isodd马上会变成对方的标志。
// isExist某棋盘格子上是否有棋子的标识true代表有棋子。
private boolean isOdd, isExist;

// 无参数的构造方法
public GoGame() {
    }

// 有参数的构造方法，初始化棋盘的数组，调用初始化棋盘的方法。
public GoGame(int chessModel) {
this.isOdd = true;
if (chessModel == 1) {
            PanelInit(20, 15, chessModel);
        }
if (chessModel == 2) {
            PanelInit(30, 20, chessModel);
        }
if (chessModel == 3) {
            PanelInit(40, 30, chessModel);
        }
    }

// 构造好棋盘的布局，只有本类能够调用，因为只有在构造初始化的时候调用，外部类不需要调用
private void PanelInit(int width, int height, int chessModel) {
this.width = width;
this.height = height;
this.chessModel = chessModel;
this.chessMapShow = new int[width + 1][height + 1];
// 行数代表高度，列数代表宽度
for (int i = 0; i <= width; i++) {
for (int j = 0; j <= height; j++) {
                chessMapShow[i][j] = -5;// 首先是不能下棋的
            }
        }
    }

// 获取是否交换棋手的标识
public boolean getIsOdd() {
return this.isOdd;
    }

// 设置交换棋手的标志。
public void setIsOdd(boolean isOdd) {
if (isOdd) {
this.isOdd = true;
        }else {
this.isOdd =false;      }

    }

// 获取该棋盘某一格子上是否有棋子的标识
public boolean getIsExist() {
return this.isExist;
    }

// 获取棋盘高度
public int getHeight() {
return this.height;

    }

// 获取棋盘宽度
public int getWidth() {
return this.width;
    }

// 获取棋盘的种类
public int getChessModel() {
return this.chessModel;
    }

// 获取棋盘的地图上的棋格子的信息。
public int[][] getChessMapShow() {
return this.chessMapShow;
    }

// 判断是下子是否横向越界，或纵向越界。
public boolean overMap(int y, int x) {
// 横向越界
if (x >= width + 20 || x < 0)
return true;
// 纵向越界
return y >= height + 20 || y < 0;
    }

// 判断是格子上是否有棋子了
public boolean chessExist(int i, int j) {
// 如果数组上已经有黑子和白子，就返回true
if (chessMapShow[i][j] == 1 || chessMapShow[i][j] == 2) {
return true;
        }
return false;
    }

// 准备下棋，把坐标xy的棋格上变成可以下棋的数字标志。
public void readyUp(int x, int y) {
// 如果坐标xy越界了棋盘数组，就退出方法。
if (overMap(x, y)) {
return;
        }
// 如果坐标xy上已经有棋子了，就退出方法。
if (chessExist(x, y)) {
this.isExist = true;
return;
        }
// 如果不存在棋子要没有越界，就把这个坐标的棋格上改为可以下棋
        chessMapShow[x][y] = 3;
    }

// 在某一位置上下棋
public void upChess(int x, int y) {
// 如果越界了，退出方法。
if (overMap(x, y)) {
return;
        }
// 如果存在棋子了，设置isExist标志成为true
if (chessExist(x, y)) {
this.isExist = true;
return;
        } else {
this.isExist = false;
if (getIsOdd()) {
// isOdd如果是true就下的是黑子，是false就下的是白子。
// 总是要把交换标识isOdd变成对方执手，让对方下棋。
                setIsOdd(false);
this.chessMapShow[x][y] = 1;
            } else {
                setIsOdd(true);
this.chessMapShow[x][y] = 2;
            }
        }
    }

// 记录电脑下子横向坐标
public void setX(int x) {
this.x = x;
    }

// 记录电脑下子的纵向坐标
public void setY(int y) {
this.y = y;
    }

// 获取电脑下子的横向坐标
public int getX() {
return this.x;
    }

// 获取电脑下子的纵向坐标
public int getY() {
return this.y;
    }

// 计算某一格子上的四个直线方向的棋子的最大值
// 左，右直线方向。
// 上下直线方向。
// 左上，右下直线方向。
// 右上，左下直线方向。
// black_or_write是传进的数值，1位黑，2为白。
public int checkMax(int x, int y, int black_or_write) {
// num是计棋子数。max_num是自大棋子数,最终的返回值。max_temp是临时的用来 记录临时的最大的棋子数。
int num = 0, max_num, max_temp = 0;
// 为了不破坏传进来的xy值，用来存储此刻棋子格子的坐标
int x_temp = x, y_temp = y;
// 指针，二维指向坐标xy为中心的八个方向，四条直线。
int x_temp1 = x_temp, y_temp1 = y_temp;
// 判断右边，接着就是判断右边。每次相对传入xy坐标循环四次。
for (int i = 1; i < 5; i++) {
            x_temp1 += 1;
if (x_temp1 > this.width) {
break;
            }
if (chessMapShow[x_temp1][y_temp1] == black_or_write) {
                num++;
            } else {
break;
            }
        }
// 判断左边，指针退指向原来的xy坐标位置
        x_temp1 = x_temp;
for (int i = 1; i < 5; i++) {
            x_temp1 -= 1;
if (x_temp1 < 0) {
break;
            }
if (chessMapShow[x_temp1][y_temp1] == black_or_write) {
                num++;
            } else {
break;
            }
        }
if (num < 5) {
            max_temp = num;
        }
// 判断上边，同样要先复原指针恢复为xy的坐标位置
        x_temp1 = x_temp;
        y_temp1 = y_temp;
        num = 0;
for (int i = 1; i < 5; i++) {
            y_temp1 -= 1;
if (y_temp1 < 0) {
break;
            }
if (chessMapShow[x_temp1][y_temp1] == black_or_write) {
                num++;
            } else {
break;
            }
        }
// 判断下边
        y_temp1 = y_temp;
        num = 0;
for (int i = 1; i < 5; i++) {
            y_temp1 += 1;
if (y_temp1 > this.height) {
break;
            }
if (chessMapShow[x_temp1][y_temp1] == black_or_write) {
                num++;
            } else {
break;
            }
        }
// 如果num大于上一次记录最大量。就把num的值传入max_num.
if (num > max_temp && num < 5) {
            max_temp = num;
        }
// 判断左上
        x_temp1 = x_temp;
        y_temp1 = y_temp;
        num = 0;
for (int i = 1; i < 5; i++) {
            x_temp1 -= 1;
            y_temp1 -= 1;
if (y_temp1 < 0 || x_temp1 < 0) {
break;
            }
if (chessMapShow[x_temp1][y_temp1] == black_or_write) {
                num++;
            } else {
break;
            }
        }
// 判断右下
        x_temp1 = x_temp;
        y_temp1 = y_temp;
for (int i = 1; i < 5; i++) {
            x_temp1 += 1;
            y_temp1 += 1;
if (y_temp1 > this.height || x_temp1 > this.width) {
break;
            }
if (chessMapShow[x_temp1][y_temp1] == black_or_write) {
                num++;
            } else {
break;
            }
        }
if (num > max_temp && num < 5) {
            max_temp = num;
        }
// 判断右上
        x_temp1 = x_temp;
        y_temp1 = y_temp;
        num = 0;
for (int i = 1; i < 5; i++) {
            x_temp1 += 1;
            y_temp1 -= 1;
if (y_temp1 < 0 || x_temp1 > this.width) {
break;
            }
if (chessMapShow[x_temp1][y_temp1] == black_or_write) {
                num++;
            } else {
break;
            }
        }
// 判断左下
        x_temp1 = x_temp;
        y_temp1 = y_temp;
        num = 0;
for (int i = 1; i < 5; i++) {
            x_temp1 -= 1;
            y_temp1 += 1;
if (y_temp1 > this.height || x_temp1 < 0) {
break;
            }
if (chessMapShow[x_temp1][y_temp1] == black_or_write) {
                num++;
            } else {
break;
            }
        }
if (num > max_temp && num < 5) {
            max_temp = num;
        }
        max_num = max_temp;
return max_num;
    }

// 判断输赢，计算机和玩家下完棋之后都要调用的方法。
public boolean judgeSuccess(int x, int y, boolean isOdd) {
// 表示棋子在xy上有一颗棋子。
int num = 1;
int arrvalue;//是谁下的子。1为黑子，2为白子。
int x_temp = x, y_temp = y;
if (isOdd) {
            arrvalue = 2;
        } else {
            arrvalue = 1;
        }
//设置横纵的两个指针。
int x_temp1 = x_temp, y_temp1 = y_temp;
// 判断右边
for (int i = 1; i < 6; i++) {
            x_temp1 += 1;
if (x_temp1 > width) {
break;
            }
if (this.chessMapShow[x_temp1][y_temp1] == arrvalue) {
                num++;
            } else {
break;
            }
        }
// 判断左边
        x_temp1 = x_temp;
for (int i = 1; i < 6; i++) {
            x_temp1 -= 1;
if (x_temp1 < 0) {
break;
            }
if (this.chessMapShow[x_temp1][y_temp1] == arrvalue) {
                num++;
            } else {
break;
            }
        }
if (num == 5) {
return true;
        }
// 判断上面
        x_temp1 = x_temp;
        y_temp1 = y_temp;
        num = 1;
for (int i = 1; i < 6; i++) {
            y_temp1 -= 1;
if (y_temp1 < 0) {
break;
            }
if (this.chessMapShow[x_temp1][y_temp1] == arrvalue) {
                num++;
            } else {
break;
            }
        }
// 判断下面
        y_temp1 = y_temp;
for (int i = 1; i < 6; i++) {
            y_temp1 += 1;
if (y_temp1 > this.height) {
break;
            }
if (this.chessMapShow[x_temp1][y_temp1] == arrvalue) {
                num++;
            } else {
break;
            }
        }
if (num == 5) {
return true;
        }
// 判断左上
        x_temp1 = x_temp;
        y_temp1 = y_temp;
        num = 1;
for (int i = 1; i < 6; i++) {
            x_temp1 -= 1;
            y_temp1 -= 1;

if (y_temp1 < 0 || x_temp1 < 0) {
break;
            }
if (this.chessMapShow[x_temp1][y_temp1] == arrvalue) {
                num++;
            } else {
break;
            }
        }
// 判断右下
        x_temp1 = x_temp;
        y_temp1 = y_temp;
for (int i = 1; i < 6; i++) {
            y_temp1 += 1;
            x_temp1 += 1;
if (y_temp1 > this.height || x_temp1 > this.width) {
break;
            }
if (this.chessMapShow[x_temp1][y_temp1] == arrvalue) {
                num++;
            } else {
break;
            }
        }
if (num == 5) {
return true;
        }
// 判断右上
        x_temp1 = x_temp;
        y_temp1 = y_temp;
        num = 1;
for (int i = 1; i < 6; i++) {
            x_temp1 += 1;
            y_temp1 -= 1;

if (y_temp1 < 0 || x_temp1 > this.width) {
break;
            }
if (this.chessMapShow[x_temp1][y_temp1] == arrvalue) {
                num++;
            } else {
break;
            }
        }
// 判断左下
        x_temp1 = x_temp;
        y_temp1 = y_temp;
for (int i = 1; i < 6; i++) {
            y_temp1 += 1;
            x_temp1 -= 1;
if (y_temp1 > this.height || x_temp1 < 0) {
break;
            }
if (this.chessMapShow[x_temp1][y_temp1] == arrvalue) {
                num++;
            } else {
break;
            }
        }
if (num == 5) {
return true;
        }
return false;
    }

// 显示赢了之后的界面
public void showSuccess(JPanel jp) {
        JOptionPane.showMessageDialog(jp, "你赢了，你好厉害", "win", JOptionPane.INFORMATION_MESSAGE);
    }

// 显示输了之后的界面
public void showDefeat(JPanel jp) {
        JOptionPane.showMessageDialog(jp, "你输了，好遗憾", "you lose", JOptionPane.INFORMATION_MESSAGE);
    }

// 计算机走棋，使用穷举法计算每一个做标点的上下左右四个方向的最大棋子数，最后得出棋子数最大值的坐标,下子
public void computerUpchess(int width, int height) {
int max_black, max_write, max_temp, max = 0;
        setIsOdd(true);// 先交换棋手，不然永远都是计算机下棋了，永远都是白子。true黑子才是黑子，是玩家下棋。
        System.out.println("计算机走棋。。。。");
for (int i = 0; i <= this.width; i++) {
for (int j = 0; j <= this.height; j++) {
// 双重循环的中，如这一点上子多，就堵住
if (!chessExist(i, j)&&!overMap(i, j)) {// 判断是否下棋
                    max_write = checkMax(i, j, 2);// 判断白子的最大值
                    max_black = checkMax(i, j, 1);
//把白子和黑子的最大值付给max_temp变量。
                    max_temp = Math.max(max_write, max_black);
if (max_temp > max) {
//把最佳下子位置记录下来。
                        max = max_temp;
this.x = i;
this.y = j;
                    }
                }
            }
        }
//下完棋一定要设置自己下棋的位置，为了计算机下棋之后判断输赢用。
//计算机下完棋之后，调用getX和getY来判断计算机输赢。
        setX(this.x);
        setY(this.y);
//下白子。
        chessMapShow[this.x][this.y] = 2;
    }

}

下面是为了界面化面板类的代码：实现了点击下棋和画出棋盘和棋子。

import java.awt.Color;
import java.awt.Graphics;
import java.awt.color.CMMException;
import java.awt.event.MouseEvent;
import java.awt.event.MouseListener;
import java.awt.event.MouseMotionListener;

import javax.swing.JOptionPane;
import javax.swing.JPanel;

/**
 * @author 王爷 此类主要是完成如下的功能 1.构建一个面板，并在面板上画棋盘。 2.处理该面板上的事件
 */
public class ChessPanel extends JPanel implements MouseListener, MouseMotionListener {

// 棋盘的高度和宽度
private int width, height;
// 为了从核心类获取棋盘的信息来画数组，这里设置一个引用。在构造方法里传入对象。
private GoGame goGame;

// 构造方法，传入核心对象，并从核心对象获取高度和宽度的属性。
public ChessPanel(GoGame goGame) {
this.goGame = goGame;
this.width = goGame.getWidth();
this.height = goGame.getHeight();
        addMouseListener(this);// 为整个花瓣添加点击事件。
    }

// 设置gogame的高度和宽度
public void setGoGame(GoGame goGame) {
this.goGame = goGame;
        width = goGame.getWidth();
        height = goGame.getHeight();
    }

// 根据坐标计算出棋盘每一个棋格的信息（如是黑子还是白子）
// 然后调用draw方法上画出棋子。draw之后自己定义。
@Override
protected void paintComponent(Graphics g) {
super.paintComponent(g);
// 画出出边界之外 的棋盘。遍历数组时一定要从0开始便利，
//不然计算机下棋不会显示，自己下棋也不能下在第一列和第一行！！！我调试过很久才调出来。
//忘要参考的读者莫要饭错误
for (int i = 0; i <= this.width; i++) {
for (int j = 0; j <= this.height; j++) {
int v = goGame.getChessMapShow()[i][j];
// i是横坐标，j是纵坐标。
                draw(g, i, j, v);
            }
        }
    }

// 根据提供的xy坐标画出棋子和棋盘。
private void draw(Graphics g, int i, int j, int v) {
//背景随便什么颜色都行，如果用常量值不爽，可以自己实例化一个Color对象出来，然后传入rgb数值。
        setBackground(Color.CYAN);
// 这样画的棋盘就不会从面板边缘开始。
int x = 20 * i + 20;
int y = 20 * j + 20;
// 先把画布都画成白色的矩形框。
if (i != width && j != height) {
            g.setColor(Color.white);
            g.fillRect(x, y, 20, 20);
            g.setColor(Color.BLACK);
            g.drawRect(x, y, 20, 20);
        }
// 画黑子
if (v == 1) {
            g.setColor(Color.black);
            g.fillOval(x - 8, y - 8, 16, 16);
            g.setColor(Color.gray);
// 绘制椭圆，分别根据左上角的横纵坐标，椭圆的高度和宽度椭圆
            g.drawOval(x - 8, y - 8, 16, 16);
        }
// 画白子
if (v == 2) {
            g.setColor(Color.white);
            g.fillOval(x - 8, y - 8, 16, 16);
            g.setColor(Color.gray);
            g.drawOval(x - 8, y - 8, 16, 16);
        }
if (v == 3) {
// 设置为青色
            g.setColor(Color.cyan);
            g.drawOval(x - 8, y - 8, 16, 16);
        }
    }

// 棋盘画布的点击事件
@Override
public void mousePressed(MouseEvent e) {
// 获取鼠标点击的坐标xy
// 因为在ChessBoard类中的MapSize()方法中，高度和宽度是width*20+50和height*20+100，所以坐标要除以20
// 而在画棋子的时候，我们为了让边缘不是在窗口的界面边缘，我们加上了一个矩形的宽度，所以下棋时要减去半个矩形的宽度。
int x = (e.getX() - 10) / 20;
int y = (e.getY() - 10) / 20;
        System.out.println("横坐标:" + x + "纵坐标:" + y);
// 如果获取的是鼠标的事件的掩码。则下棋
if (e.getModifiers() == MouseEvent.BUTTON1_MASK) {
            goGame.upChess(x, y);
        }
        System.out.println(goGame.getIsOdd() + "" + goGame.getChessMapShow()[x][y]);
        repaint();
// 下完棋之后我，我们根据这个坐标来判断玩家的输赢
// 用户判断输赢时是根据鼠标获取的位置对映的数组坐标来判断的。
if (goGame.judgeSuccess(x, y, goGame.getIsOdd())) {
            goGame.showSuccess(this);
// 不能让鼠标继续下棋了。鼠标点击面板没有用了。所以销毁传入的鼠标对象
            e.consume();
// 把状态量改为false，表示不是计算机下棋。
            ChessBoard.isComputer = false;
        }
// 判断是否为人机对弈，如果是人机对弈而且棋子不存在。，就计算机下棋
if (ChessBoard.isComputer && !goGame.getIsExist()) {
            goGame.computerUpchess(goGame.getWidth(), goGame.getHeight());
            repaint();
// 计算机下棋，他会记录自己下的坐标，所以在判断输赢时，要用getX和getY方法判断。
            System.out.println(goGame.getIsOdd());
            System.out.println(goGame.getX()+" "+goGame.getY());
if (goGame.judgeSuccess(goGame.getX(), goGame.getY(), goGame.getIsOdd())) {
                goGame.showDefeat(this);
// 计算机赢了也不能下棋了。所以销毁传入的鼠标对象
                e.consume();
            }
        }
    }

// 鼠标拖动事件
@Override
public void mouseMoved(MouseEvent e) {
int x = (e.getX() - 10) / 20;
int y = (e.getY() - 10) / 20;
// 鼠标移动到哪一点，数组就会响应的变为可以下棋状态。
        goGame.readyUp(x, y);
        repaint();
    }

// 显示赢了之后的界面
public void showSuccess(JPanel jp) {
        JOptionPane.showMessageDialog(jp, "你赢了，你好厉害", "win", JOptionPane.INFORMATION_MESSAGE);
    }

// 显示输了之后的界面
public void showDefeat(JPanel jp) {
        JOptionPane.showMessageDialog(jp, "你输了，好遗憾", "you lose", JOptionPane.INFORMATION_MESSAGE);
    }

@Override
public void mouseDragged(MouseEvent e) {
    }

@Override
public void mouseClicked(MouseEvent e) {
    }

@Override
public void mouseEntered(MouseEvent e) {
    }

@Override
public void mouseExited(MouseEvent e) {
    }

@Override
public void mouseReleased(MouseEvent e) {
    }

}

下面是窗口类。用于实现窗口话和点击菜单会激发不同的事件。如：关闭窗口时系统也退出。游戏棋盘的选择，游戏模式的选择。游戏窗口视图的选择。

import java.awt.Container;
import java.awt.Graphics;
import java.awt.Window;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.event.WindowAdapter;
import java.awt.event.WindowEvent;

import javax.swing.ButtonGroup;
import javax.swing.JFrame;
import javax.swing.JMenu;
import javax.swing.JMenuBar;
import javax.swing.JMenuItem;
import javax.swing.JOptionPane;
import javax.swing.JRadioButton;
import javax.swing.JRadioButtonMenuItem;
import javax.swing.SwingUtilities;
import javax.swing.UIManager;

//这个类主要是加载五子棋的整个窗口以及菜单
public class ChessBoard extends JFrame implements ActionListener {

// 可选的棋盘大小
private String[] strSize = { "20*15", "30*20", "40*30" };
// 可选的对战模式
private String[] strModel = { "人机对战", "人人对战" };
// 用连个boolean 来判断是人机还是人人，isComputer和checkcomputer为true是为了默认开局方式为人机。
public static boolean isComputer = true, checkComputer = true;
// 窗口的宽和高
private int height, width;
// 核心类对象
private GoGame goGame;
// 棋盘对象
private ChessPanel chessPanel;

// 构造五子棋的窗体
public ChessBoard() {
this.setTitle("五子棋---个人制作");
// 初始化核心类的对对象。
        goGame = new GoGame(1);
// 使用核心类，初始化面板对象。
        chessPanel = new ChessPanel(goGame);
// 获取本窗口的容器。
        Container con = this.getContentPane();
// 容器里加入面板，并设置布局为中心。
        con.add(chessPanel, "Center");
//把窗口设置为大小不可调整。
this.setResizable(false);
//添加一个窗口监听事件，主要是实现按关闭按钮能够关闭系统，退出虚拟机。为了精简代码，这里使用了匿名内部类。
this.addWindowListener(new WindowAdapter() {
@Override
public void windowClosing(WindowEvent e) {
                System.exit(0);
            }
        });
// 先使用类内部的设置窗口的方法来初始化窗口大小
this.MapSize(20, 15);
// 创建窗口的菜单条，一方便
        JMenuBar mbar = new JMenuBar();
this.setJMenuBar(mbar);
// 创建游戏菜单
        JMenu gameMenu = new JMenu("游戏");
// 将菜单加入到菜单条,自己创建一个方法反回一个已经构造好的菜单。加在菜单条上。
        mbar.add(makeMenu(gameMenu, new Object[] {
"开局", "棋盘", "模式", null, "退出" }, this));
// 创建视图菜单
        JMenu lookMenu = new JMenu("视图");
// 将菜单添加到菜单条
        mbar.add(makeMenu(lookMenu, new Object[] { 
"Metal", "Motif", "Windows" }, this));
// 创建帮助菜单
        JMenu helpMenu = new JMenu("帮助");
// 将菜单添加到菜单条
        mbar.add(makeMenu(helpMenu, new Object[] { 
"关于" }, this));

    }

// 获取人机iscompputer
public boolean getIsComputer() {
return this.isComputer;
    }

// 构造五子棋的主菜单，第一步是要创建一个菜单的引用，以便之后创建菜单实例返回。
public JMenu makeMenu(Object parent, Object items[], Object target) {
//创建一个菜单引用。
        JMenu m = null;
//如果传入的本来就是菜单，则直接强制转换。如果是字符串，则使用字符创建菜单。
if (parent instanceof JMenu) {
            m = (JMenu) parent;
        } else if (parent instanceof String) {
            m = new JMenu((String) parent);
        } else {
return null;
        }
//下面是为菜单构建菜单项。还是使用方法返回。
for (int i = 0; i < items.length; i++) {
if (items[i] == null) {
                m.addSeparator();
            } else if (items[i] == "棋盘") {
                JMenu jm = new JMenu("棋盘");
                ButtonGroup group = new ButtonGroup();
                JRadioButtonMenuItem rmenu;
for (int j = 0; j < strSize.length; j++) {
                    rmenu = makeRadioButtonMenuItem(strSize[j], target);
if (j == 0) {
                        rmenu.setSelected(true);
                    }
//先把多按钮加入到菜单中，再把多按钮加入到按钮组里，这样才能实现单选。
                    jm.add(rmenu);
                    group.add(rmenu);
                }
                m.add(jm);
            } else if (items[i] == "模式") {
                JMenu jm = new JMenu("模式");
                ButtonGroup group = new ButtonGroup();
                JRadioButtonMenuItem rmenu;
for (int h = 0; h < strModel.length; h++) {
                    rmenu = makeRadioButtonMenuItem(strModel[h], target);
if (h == 0) {
                        rmenu.setSelected(true);
                    }
                    jm.add(rmenu);
                    group.add(rmenu);
                }
//记住，一定要是加入菜单条里的菜单
                m.add(jm);
            } else {
//如果菜单项没有在包含多选项，则用方法直接构造一个菜单项返回并添加到菜单里。
                m.add(makeMenuItem(items[i], target));
            }
        }
return m;
    }

// 构造五子棋的菜单项，构造方法和上面构造菜单的不部分类似。不过 得添加监听事件
private JMenuItem makeMenuItem(Object item, Object target) {
        JMenuItem menuItem = null;
if (item instanceof String) {
            menuItem = new JMenuItem((String) item);
        } else if (item instanceof JMenuItem) {
            menuItem = (JMenuItem) item;
        } else {
return null;
        }
if (target instanceof ActionListener) {
            menuItem.addActionListener((ActionListener) target);
        }
return menuItem;
    }

// 构造五子棋的单选按钮式菜单项，和上面的方法非常类似。不再赘述。
private JRadioButtonMenuItem makeRadioButtonMenuItem(Object item, Object target) {
        JRadioButtonMenuItem jRadioButtonMenuItem = null;
if (item instanceof String) {
            jRadioButtonMenuItem = new JRadioButtonMenuItem((String) item);
        } else if (item instanceof JRadioButtonMenuItem) {
            jRadioButtonMenuItem = (JRadioButtonMenuItem) item;
        } else {
return null;
        }
if (target instanceof ActionListener) {
            jRadioButtonMenuItem.addActionListener((ActionListener) target);
        }
return jRadioButtonMenuItem;
    }

// 设置界面大小
public void MapSize(int w, int h) {
//这里设置的宽度和高度，和鼠标点击时获取坐标值有很大的关联。
        setSize(w * 20 + 50, h * 20 + 100);
if (this.checkComputer) {
this.isComputer = true;
        } else {
this.isComputer = false;
        }
        chessPanel.setGoGame(goGame);
        chessPanel.repaint();
    }

// 重新开始
public void restart() {
int modelChess = goGame.getChessModel();
if (modelChess <= 3 && modelChess >= 1) {
            goGame = new GoGame(modelChess);
            MapSize(goGame.getWidth(), goGame.getHeight());
        } else {
            System.out.println("\u81EA\u5B9A\u4E49");
        }
    }

@Override
// 实现ActionListenner的主要方法。
public void actionPerformed(ActionEvent e) {
        String arg = e.getActionCommand();
try {
if (arg.equals("Windows")) {
                UIManager.setLookAndFeel(
"com.sun.java.swing.plaf.windows.WindowsLookAndFeel");
            } else if (arg.equals("Motif")) {
                UIManager.setLookAndFeel(
"com.sun.java.swing.plaf.motif.MotifLookAndFeel");
            } else {
                UIManager.setLookAndFeel(
"javax.swing.plaf.metal.MetalLookAndFeel");
            }
            SwingUtilities.updateComponentTreeUI(this);
        } catch (Exception e2) {
        }
if (arg.equals("20*15")) {
this.width = 20;
this.height = 15;
            goGame = new GoGame(1);
            MapSize(this.width, this.height);
            SwingUtilities.updateComponentTreeUI(this);

        }
if (arg.equals("30*20")) {
this.width = 30;
this.height = 20;
            goGame = new GoGame(2);
            MapSize(this.width, this.height);
            SwingUtilities.updateComponentTreeUI(this);

        }
if (arg.equals("40*30")) {
this.width = 40;
this.height = 30;
            goGame = new GoGame(3);
            MapSize(this.width, this.height);
            SwingUtilities.updateComponentTreeUI(this);

        }
if (arg.equals("人机对弈")) {
this.checkComputer = true;
this.isComputer = true;
            goGame = new GoGame(goGame.getChessModel());
            MapSize(goGame.getWidth(),goGame.getHeight());
            SwingUtilities.updateComponentTreeUI(this);
        }
if (arg.equals("人人对弈")) {
this.checkComputer = true;
this.isComputer = true;
            goGame = new GoGame(goGame.getChessModel());
            MapSize(goGame.getWidth(),goGame.getHeight());
            SwingUtilities.updateComponentTreeUI(this);
        }
if (arg.equals("开局")) {
            restart();
        }
if (arg.equals("关于")){

            JOptionPane.showMessageDialog(this, "五子棋游戏测试版本", "关于", 0);
        }
if (arg.equals("退出")) {
            System.exit(0);
        }
    }

}

这里是为了练习项目。为大家提供的代码和注释，应该是一看就能看懂的，非常适合初学者。