五子棋的Java实现 详解

最近用Java写了一个有人机对战和人人对战两种模式的五子棋小游戏，也算是有自己一定的心得，现在把它分享出来。代码我会放在最后面，先把五子棋的思路捋清楚

一、首先上界面图

这是我五子棋的界面，比较简单，大家可以根据自己的想法随意DIY.

二、如何实现界面？

这个五子棋界面，由四个类实现，分别是：
JFrame（作为顶层容器类的JFrame用来添加其他的所有组件）
JPanel（在界面中用来分别添加棋盘界面和按钮界面）
JButton（在界面作为按键如“开始”“认输”“重新开始”按键）
JRadioButton（在界面中作为单选按钮如“人人对战”“人机对战”）

界面中有两个JPanel面板对象，一个在界面的左边用来绘制棋盘，一个在界面的右边用来放置按键。
给出界面实现代码

public class FiveChess extends JPanel{    public Graphics g;                          //五子棋盘里面的Graphics属性用来画图    public static void  main (String args[]){        FiveChess fc=new FiveChess();           //实例化五子棋盘类得到五子棋盘对象fc        fc.go();                                //五子棋盘对象fc调用go()    }    public void setG(Graphics g){               //五子棋盘类用来设置Graphics属性的方法        this.g=g;    }    public void go(){        /*         * 创建一个窗体，设置窗体里的属性         */        JFrame frame=new JFrame();              //实例化一个窗体对象frame        frame.setTitle("五子棋");                  //设置窗体的标题        frame.setSize(800,500);                 //设置窗体的大小        frame.setDefaultCloseOperation(3);        /*         * 添加两个面板 利用board布局 一个放中间 用来画五子棋的棋盘 一个放东边用来放置按钮         */        JPanel buttonpanel=new JPanel();                        //实例化一个面板对象buttonpanel        buttonpanel.setPreferredSize(new Dimension(300,500));//设置buttonpanel大小 只有窗体对象能够用setSize()        buttonpanel.setBackground(Color.white);             //设置buttonpanel对象的背景颜色        /*         * 添加按钮         */         //实例化三个按钮对象            JButton bstart=new JButton("开始");                       JButton bquit=new JButton("认输");        JButton bundo=new JButton("悔棋");        //设置三个按钮对象的大小        bstart.setPreferredSize(new Dimension(200,50));             bquit.setPreferredSize(new Dimension(200,50));        bundo.setPreferredSize(new Dimension(200,50));        //将这三个按钮对象添加到面板对象bp中去        buttonpanel.add(bstart);                                            buttonpanel.add(bquit);        buttonpanel.add(bundo);        //实例化按钮组对象bg        ButtonGroup bg=new ButtonGroup();                       //实例化两个单选按钮对象        JRadioButton bpvp=new JRadioButton("人人对战");         JRadioButton bpvr=new JRadioButton("人机对战");        //设置两个单选按钮对象的大小        bpvp.setPreferredSize(new Dimension(200,50));           bpvr.setPreferredSize(new Dimension(200,50));        //将这两个单选按钮对象设为透明背景        bpvr.setOpaque(false);                                  bpvp.setOpaque(false);        bg.add(bpvp);                                   //将这两个单选按钮对象添加到按钮组对象bg中        bg.add(bpvr);        //将这两个单选按钮对象添加到面板对象buttonpanel中        buttonpanel.add(bpvp);                                          buttonpanel.add(bpvr);          this.setBackground(Color.gray);                 //棋盘对象设置背景色        /*         * 窗体布局，将棋盘面板和按钮面板合理地布局在frame窗体对象上         */        BorderLayout bl=new BorderLayout();             //实例化一个布局对象             frame.setLayout(bl);                            //将窗体对象frame设置为BorderLayout        frame.add(this,BorderLayout.CENTER);            //把棋盘对象放在窗体对象的中间        frame.add(bp,BorderLayout.EAST);                //把按钮面板放在窗体对象的东边        frame.setVisible(true);                         //窗体对象设置为可见        //棋盘对象设置Graphics属性        g=this.getGraphics();       }}

以上这段代码并没有给出如何画出15*15的棋盘
因为棋盘是在左边板上画出来的我们可以利用左边面板的重绘paint（）方法画15*15棋盘

   /*     *画五子棋棋盘的方法     */    public void draw(Graphics ag){        Graphics2D g=(Graphics2D)ag;        g.setRenderingHint(RenderingHints.KEY_ANTIALIASING,                RenderingHints.VALUE_ANTIALIAS_ON);        for(int i=0;i<15;i++){            for(int j=0;j<15;j++){                /*                 * 首先把棋盘重新画一遍                 */                g.setColor(Color.black);                g.drawLine(30,30+i*30,450,30+i*30); //画横线                g.drawLine(30+i*30,30,30+i*30,450); //画竖线            }        }

重写paint（）方法

    public void paint(Graphics g){        super.paint(g);        draw(g);    }

有了以上这几段代码我们就能完全实现如图所示的界面了。

有了界面之后，棋子呢？

当我们做好界面之后理所应当地需要在棋盘面板上放置棋子。
Java是一门面向对象的语言，我们可以把棋子作为一个类。
在棋盘上每一个横竖线交叉的地方都应该有一个棋子，在相对应的地方没有下棋的时候，棋子是隐形的棋子状态flag为0，在相对应的位置下完棋之后棋子状态flag为1（白棋）或者2（黑棋）。

public class chess {     public int X,Y;    // X,Y是棋子对应在棋盘上的坐标,我们之后就是利用棋子的坐标，在棋盘上画出它。     public int flag;   //代表棋子的三种状态flag:0 没有落子 flag:1 白子 flag:2 黑子     public int value;  //该棋子的权值      public chess(){         X=0;         Y=0;         flag=0;         value=0;     }     public chess(int x,int y){         X=x;         Y=y;         flag=0;         value=0;     }}

我们可以定义一个15*15的二维数组 数组下标代表棋子在棋盘的相应位置，而棋子的X Y属性代表棋子在棋盘上的坐标值。最左上角的棋子坐标为X：30，Y:30;在二维数组中为行下标为0 列下标为0

for(int i=0;i<15;i++){            for(int j=0;j<15;j++){                chess ch=new chess((j+1)*30,(i+1)*30)                xy[i][j]=ch;            }                       }

**行列下标和棋子坐标对应关系为：
i=xy[][].Y/30-1; j=xy[][].X/30-1;**

如何让棋子在棋盘上出现呢？我们首先要用setGraphics（）方法获得棋盘上的“画笔”g,
在设置为对应的白色或黑色之后
然后利用g.fillOval()方法在棋盘界面上画出白色棋子或黑色棋子。
当棋子出现在棋盘上之后，那么棋子的状态flag属性就应该从“0”（没有落子）转变为“1”（白棋）或“2”（黑棋）
在这里还应当设置一个变量color，用来记录和判断当前下的是白棋还是黑棋，假设用color为“1”代表当前下的是白棋，color为“2”代表当前下的是黑棋。在下完黑棋之后应当把color置为“1”，下次就下白棋，下完白棋之后把color设置为“2”，下次就下黑棋。

下完棋子之后呢？

我们在下完棋子之后就应当判断是否有五颗同颜色棋子相连了，我们不需要遍历整个棋盘去判断，只需要在最后落子的地方，从横向，竖向，正对角线，反对角线四个大方向上去判断是否有相同颜色的棋子连成一条线。
先上这部分代码

/* * 方法的参数是棋子对象 */public void checkChess(chess ch){        //实例化一个弹窗对象，后面用来提白方还是黑方获胜        JOptionPane op=new JOptionPane();        /*         * 初始化变量用来存储在 水平 垂直 正对角线 反对角线方向上的连续棋子         */        int count1=1;        int count2=1;        int count3=1;        int count4=1;        /*         * 将棋子的坐标值 转换为对应的数组下标值 xy[0][0] 的坐标是（30 ，30）xy[0][1]的坐标是（60,30）         */        int x=ch.Y/30-1;   //行坐标        int y=ch.X/30-1;   //列坐标        /*         * 水平方向上的检测         */        for(int j=y+1;j<15;j++){                                //行坐标不变 列坐标递增 检测ch右边的落子情况            if(xy[x][y].flag==xy[x][j].flag){ //如果ch右边的棋子和ch颜色一样 计数加一                count1++;        }/如果ch右边的棋子和ch颜色不一样 则退出计数            else                break;                                          //如果不是的话退出判断        }        for(int j=y-1;j>=0;j--){                                //行坐标不变 列坐标递减 检测ch左边的落子情况            if(xy[x][y].flag==xy[x][j].flag){                count1++;            }            else                break;        }        //水平方上的落子情况检测完        if(count1>=5){                                              if(xy[x][y].flag==1)                op.showMessageDialog(null, "白棋胜出");             else                op.showMessageDialog(null, "黑棋胜出");         }        /*         * 垂直方向上的检测         */        for(int i=x-1;i>=0;i--){                                //列坐标不变 行坐标递减 检测ch上面的落子情况                   if(xy[x][y].flag==xy[i][y].flag&&xy[x][y].flag!=0){                count2++;            }            else                break;        }                                                       //列坐标不变 行坐标递加  检测ch下面的落子情况          for(int i=x+1;i<15;i++){                                            if(xy[x][y].flag==xy[i][y].flag&&xy[x][y].flag!=0){                count2++;            }            else                break;        }        // 垂直方向上的棋子情况检测完        if(count2>=5){                                              if(xy[x][y].flag==1)                op.showMessageDialog(null, "白棋胜出");             else                op.showMessageDialog(null, "黑棋胜出");         }        /*         * 正对角线上面的检测         */        for(int i=x-1,j=y+1;i>=0&&j<15;i--,j++){                // 行递减 列递加            if(xy[x][y].flag==xy[i][j].flag&&xy[x][y].flag!=0){                count3++;            }            else break;        }        for(int i=x+1,j=y-1;j>=0&&i<15;j--,i++){                //行递加 列递减            if(xy[x][y].flag==xy[i][j].flag&&xy[x][y].flag!=0){                count3++;            }            else break;        }        //正对角线上检测完毕        if(count3>=5){            if(xy[x][y].flag==1)                op.showMessageDialog(null, "白棋胜出");             else                op.showMessageDialog(null, "黑棋胜出");        }        /*         * 反对角线上的检测              */        for(int i=x+1,j=y+1;i<15&&j<15;i++,j++){                //行递加列递加            if(xy[x][y].flag==xy[i][j].flag&&xy[x][y].flag!=0){                count4++;            }            else break;        }        for(int i=x-1,j=y-1;j>=0&&i>=0;j--,i--){            if(xy[x][y].flag==xy[i][j].flag&&xy[x][y].flag!=0){                count4++;            }            else break;        }        //反对角线上检测完毕        if(count4>=5){            if(xy[x][y].flag==1)                op.showMessageDialog(null, "白棋胜出");             else                op.showMessageDialog(null, "黑棋胜出");        }    }

如何实现按键点击和落子？

当我们是实现了界面之后，理所应当的，接下来就是实现点击按键和落子的功能了，如何达到在点击按键和落子之后五子棋界面会有相应的反应呢？这需要我们用到事件监听机制，为按键加上监听。
按键点击的事件监听，我们要用到ActionListener接口。
在棋盘上落子实际上就是点击棋盘，棋盘上相应的位置画出棋子。我们可以用到MouseAdapter适配器
定义一个继承了MouseAdapter适配器实现了ActionListenner接口的事件监听类listener
给出对应部分代码

package com.ly.fiveChessV2;import java.awt.Color;import java.awt.Graphics;import java.awt.Graphics2D;import java.awt.RenderingHints;import java.awt.event.ActionEvent;import java.awt.event.ActionListener;import java.awt.event.MouseAdapter;import java.awt.event.MouseEvent;import java.util.HashMap;import javax.swing.JOptionPane;import javax.swing.JPanel;/* * 点击按钮 点击棋盘面板 */public class listener extends MouseAdapter implements ActionListener{    int mode;    int x,y;                    //x y是鼠标在棋盘界面上获得的坐标    private Graphics2D g;       //画笔用来绘图    int chesscount;             //连成一条线的同一颜色棋子数量    public chess [][]xy;        //定义一个棋子数组    int col=1;                  //定义一个颜色标志位 1：白色2：黑色    chess chessnew=new chess(); //用一个棋子代表最近下的棋    public JPanel panel;    /*     * 将棋盘上的画笔g赋值给属性g     */    public void setG(Graphics g){        this.g=(Graphics2D)g;    }    /*     * 把棋盘面板对象传过来     */    public void setP(JPanel panel){        this.panel=panel;    }    /*     * 将棋子数组传入     */    public void setChess(chess [][]xy){        this.xy=xy;    }    /*     *处理按键事件     */    public void actionPerformed(ActionEvent e){        JOptionPane op=new JOptionPane();        String str= e.getActionCommand();        /*         * 认输按键         */        if(str.equals("认输")){            if(col==1){            op.showMessageDialog(null, "白棋认输,黑棋胜");             }            else{                op.showMessageDialog(null, "黑棋认输,白棋胜");                 }            for(int i=0;i<15;i++){                for(int j=0;j<15;j++){                    xy[i][j].flag=0;                }            }            panel.paint(g);        }        /*         * 悔棋按键         */        if(str.equals("悔棋")){               //悔棋应该是利用棋盘界面的重画paint（）方法            if(chessnew.flag==1){                col=1;                System.out.println("悔棋的是白棋，白棋再落一子");            }            else if(chessnew.flag==2){                col=2;                System.out.println("悔棋的是黑棋，黑棋再落一子");            }            chessnew.flag=0;                //把最近一次的棋子抹除掉            panel.paint(g);            for(int i=0;i<15;i++){                for(int j=0;j<15;j++){                    if(xy[i][j].flag!=0){                        if(xy[i][j].flag==1){                            g.setColor(Color.white);                            g.fillOval(xy[i][j].X-10, xy[i][j].Y-10,20,20);                        }                        else{                            g.setColor(Color.black);                            g.fillOval(xy[i][j].X-10, xy[i][j].Y-10,20,20);                        }                    }                }            }            System.out.println("悔棋");        }        if(str.equals("人人对战")){            mode=11;        }        if(str.equals("人机对战")){            mode=12;        }    }    /*     * 处理鼠标点击事件     */    public void mouseClicked(MouseEvent e) {        /*         * 画笔抗锯齿         */        g.setRenderingHint(RenderingHints.KEY_ANTIALIASING,                RenderingHints.VALUE_ANTIALIAS_ON);        /*         * 获取鼠标点击的x和y坐标         */        x=e.getX();        y=e.getY();         /*         * 由鼠标的位置 得到棋子圆心该放的位置         */            for(int i=0;i<15;i++){                for(int j=0;j<15;j++){                      //循环遍历数组找到鼠标点击的最近的格子                    if(Math.abs(x-xy[i][j].X)<10&&Math.abs(y-xy[i][j].Y)<10){                        if(xy[i][j].flag==0){               //判断点击处是否没有落过子                            if(col == 1){                   //判断棋子该下的颜色                                g.setColor(Color.white);                                System.out.println("white");                                g.fillOval(xy[i][j].X-10, xy[i][j].Y-10,20,20);                                xy[i][j].flag=1;            //flag为1表示下的是白棋                                chessnew=xy[i][j];          //将这一步下的棋保存起来                                col=2;                      //下一次下黑旗                            }                            else if(col==2){                                g.setColor(Color.black);                                System.out.println("black");                                g.fillOval(xy[i][j].X-10, xy[i][j].Y-10,20,20);                                xy[i][j].flag=2;            //flag为1表示下的是黑旗                                col=1;                      //下一次下白棋                                        }                        checkChess( xy[i][j]);                        // 落完子 判断输赢之后 电脑落子 判断输赢                        }                           else                                //已经有棋子落下过                        System.out.println("这里不能落子");                    }                }            }        }    }}

在写完事件监听类之后我们应该实例化一个事件监听类对象，并为按键和棋盘添加事件监听。
附上相关代码

        /*         * 实例化一个监听对象         * 为各个组件加上监听         */        listener l=new listener();        l.setG(g);        l.setP(this);        l.setChess(xy);        this.addMouseListener(l);        bquit.addActionListener(l);        bundo.addActionListener(l);        bstart.addActionListener(l);        bpvp.addActionListener(l);        bpvr.addActionListener(l);        this.setG(g);                   //棋盘对象设置Graphics属性

有了以上代码我们的五子棋就能实现人人对战的功能。

如何实现人机对战？

要实现人机对战，那么就要让电脑知道棋子该下到哪一个位置，我们可以通过计算每一个位置上隐形棋子的权值（只有没下过的棋子才需要考虑）。电脑优先下权值大的棋子，然后判断一次输赢。

如何确定棋子的权值？

我的方法是用一个字符串记录棋子水平方向的、竖直方向上的、正对角线方向上、反对角线方向上的落子情况。然后根据落子情况，给该棋子赋值。
我们先要给出隐形棋子各个方向上可能的情况，和这种情况对应的权值。
我们可以利用哈希表实现

//首先实例化一个哈希表对象 HashMap<String,Integer> hm = new HashMap<String,Integer>();

隐形棋子为“0”，白子为“1”，黑子为“2”；
上图对应的字符串即为“2022”(黑子、隐形棋子、黑子、黑子)

hm.put("2022",10);

我把上图中情况的棋子的权值设置为10，当我们以后检测到隐形棋子周围的落子情况之后，就能取出对应的权值。
比如字符串S为“2022”；

int value=hp.get(S);

那么value的值就是10；
当我们把一个隐形棋子的水平、竖直、正对角线、斜对角线方向上的情况全都统计完并把四个方向上的权值相加，得到该棋子最终的权值，下面给出计算权值的代码方法caculate()

public void caculate(chess ch){        String str="0";     //用一个字符串来记录该棋子旁边的落子情况        int x=ch.Y/30-1;    //把ch棋子对应的横纵坐标转换成在棋子数组里的行和列        int y=ch.X/30-1;            hashInit();        /*         * 计算该位置棋子的权值         * 参数为一个棋子 棋子flag有三种状态 0：还没有落子 1：落白子 2：落黑子         */        if(ch.flag==0){                 //只有没有当棋子没有落下的时候才要计算该棋子的权值            Integer val;             for(int j=y+1;j<15;j++){   //记录棋子右边的落子情况 是列在变                if(xy[x][j].flag==0){   //该棋子右边没有落子                    break;              //不用记录直接退出遍历循环                }                else                     if(xy[x][j].flag==1){                        str=str+1;  //str在左边 往右加                    }                    else if(xy[x][j].flag==2){                        str=str+2;  //str在左边 往右加                        break;                    }            }            // 水平方向上检测棋子 往左看            for(int j=y-1;j>=0;j--){                if(xy[x][j].flag==0){   //该棋子左边没有落子                    break;              //不用记录直接退出遍历循环                }                else if(xy[x][j].flag==1){                    str=1+str; //str在右边 往左加                }                else if(xy[x][j].flag==2){                    str=2+str;  //str在右边 往左加                    break;                }            }             // 到这里之后棋子ch的左右情况就统计完了 str代表统计情况 利用str在哈希表对象中得到对应的键值             val=hm.get(str);            System.out.println("水平方向："+x+"行"+y+"列棋子 str:"+str);            if(val!=null){                xy[x][y].value+=val;  //把对应的键值加到棋子中去            }            str="0";            //竖直方向上 往上看            for(int i=x-1;i>=0;i--){                if(xy[i][y].flag==0){                    break;                }                else if(xy[i][y].flag==1){                    str=1+str;                }                else if(xy[i][y].flag==2){                    str=2+str;                    break;                }            }            //竖直方向上 往下看            for(int i=x+1;i<15;i++){                if(xy[i][y].flag==0){                    break;                }                else if(xy[i][y].flag==1){                    str=str+1;                }                else if(xy[i][y].flag==2){                    str=str+2;                    break;                }            }            System.out.println("竖直方向："+x+"行"+y+"列棋子 str:"+str);            val=hm.get(str);                if(val!=null){                    xy[x][y].value+=val;                }            str="0";            //正对角线方向上 向上            for(int i=x-1,j=y+1;i>=0&&j<15;i--,j++){                    if(xy[i][j].flag==0){                        break;                    }                    else if(xy[i][j].flag==1){                        str=1+str;                    }                    else if(xy[i][j].flag==2){                        str=2+str;                        break;                    }            }            //正对角线方向上 向下            for(int i=x+1,j=y-1;i<15&&j>=0;i++,j--){                    if(xy[i][j].flag==0){                        break;                    }                    else if(xy[i][j].flag==1){                        str=str+1;                    }                    else if(xy[i][j].flag==2){                        str=str+2;                        break;                    }            }            System.out.println("正对角线上"+x+"行"+y+"列棋子str:"+str);            val=hm.get(str);            if(val!=null)                xy[x][y].value+=val;            str="0";            //反对角线方向上 向上            for(int i=x-1,j=y-1;i>=0&&j>=0;i--,j--){                    if(xy[i][j].flag==0){                        break;                    }                    else if(xy[i][j].flag==1){                        str=1+str;                    }                    else if(xy[i][j].flag==2){                        str=2+str;                        break;                    }                   }            //反对角线方向上 向下            for(int i=x+1,j=y+1;i<15&&j<15;i++,j++){                    if(xy[i][j].flag==0){                        break;                    }                    else if(xy[i][j].flag==1){                        str=str+1;                    }                    else if(xy[i][j].flag==2){                        str=str+2;                        break;                    }            }            System.out.println("反对角线上"+x+"行"+y+"列棋子str:"+str);            val=hm.get(str);            if(val!=null)                xy[x][y].value+=val;            str="0";            System.out.println(x+"行"+y+"列棋子权值:"+xy[x][y].value);        }    }

有了计算一个棋子权值的方法那么，接下来然计算机决定在哪里落子就很容易了。我们可以再写一个方法AI（），循环遍历棋子数组，在隐形棋子里找出权值最大的一个棋子，然后落子。

public void AI(){        int x,y;        // 定义一个棋子变量        chess ch =new chess();        //遍历二维棋子数组 计算出每一个未落子棋子权值        for(int i=0;i<15;i++){            for(int j=0;j<15;j++){                System.out.println("计算"+i+"行"+j+"列 棋子");                caculate(xy[i][j]);            }        }        //遍历整个二维棋子数组，找出权值最大的棋子          for(int i=0;i<15;i++){            for(int j=0;j<15;j++){                if(xy[i][j].value>=ch.value){                    ch=xy[i][j];                }            }        }        System.out.println("权值最大的棋子 "+(ch.Y/30-1)+"行"+(ch.X/30-1)+"列");        //落子权值最大的棋子        x=ch.Y/30-1;        y=ch.X/30-1;        xy[x][y].flag=2;        g.setColor(Color.black);        g.fillOval(xy[x][y].X-10, xy[x][y].Y-10,20,20);        //清空棋子的权值        for(int i=0;i<15;i++){            for(int j=0;j<15;j++){                xy[i][j].value=0;            }        }    }

哈希表中五子棋的情况怎么给？

有人可能会说，下一盘五子棋那么多的棋子，怎么事先给出棋子的落子情况，和设置对应的落子情况呢？
其实 五子棋的落子情况需要考虑的不过是 活二 跳二 活三 眠三 活四 眠四之类的
我在这里给出活二 跳二 活三 眠三 活四 眠四之类相关介绍的链接 http://game.onegreen.net/wzq/HTML/142336.html

好了到这里最主要的代码已经讲解完了，大家要是有什么不清楚的地方可以给我留言。