精华内容
下载资源
问答
  • Java五子棋项目学习思路记录

    千次阅读 2019-03-10 16:17:58
    在同学的指点下,打算做个Java五子棋项目练手。 参照 HK云飞 Java五子棋小游戏(原创) https://blog.csdn.net/qq_40595913/article/details/81563301 此篇原创文章和代码学习实现Java五子棋小项目。记录一些学习...

    在同学的指点下,打算做个Java五子棋项目练手。
    参照

    HK云飞 Java五子棋小游戏(原创)
    https://blog.csdn.net/qq_40595913/article/details/81563301

    此篇原创文章和代码学习实现Java五子棋小项目。记录一些学习心得。

    无Java经验和基础小白,看了清华大学出版社陈国军主编的《Java程序设计基础(第5版)》学习之后,基本对Java有个概念,找个入门项目加深理解,学会应用。

    话说CSDN也是第一次学着使用,怎么插入代码呢……

    package Charlie.demo;
    
    import java.awt.Color;
    import java.awt.Font;
    import java.awt.Graphics;
    import java.awt.Toolkit;                //抽象类,获得屏幕的长度和高度的方法包含在内
    import java.awt.image.BufferedImage;
    
    
    import javax.swing.JFrame;
    public class FiveGame extends JFrame
    {
        //设置游戏界面
    		/*	屏幕分辨率求法:
    				int w = f.getToolkit().getScreenSize().width;//宽度
    				int h = f.getToolkit().getScreenSize().height;//高度
    		Toolkit.getDefaultToolkit().getScreenSize().width   与上面等同
    		都是用来获取屏幕的宽高,
    		this.setLocation((width - 500) / 2 , (height - 500) / 2 );
    		这是使你的窗口能够居中显示,这样看起来美观。
    	*/
    		int width = Toolkit.getDefaultToolkit().getScreenSize().width;
    		int height = Toolkit.getDefaultToolkit().getScreenSize().height;
    		int allChess[][]=new int[15][15]; // 用数组来保存棋子,0表示无子,1表示黑子,2表示白子。15行,15列的数组
        boolean isblack = true;//用来表示黑子还是白子, true表示黑子   false表示白子
        boolean canPlay = true;// 用来表示当前游戏是否结束
        String message = "黑方先行";
        String blackMessage = "无限制";
        String whiteMessage = "无限制";
        public FiveGame()  //FI类的构造方法
        {
            this.setTitle("五子棋1.0");  //在构造方法内调用另一个构造方法,this关键字必须写在构造方法内的第一行位置
            this.setSize(500,500);
            this.setLocation((width - 500) / 2 , (height - 500) / 2 );//设置组件显示位置的左上角坐标(x,y)
            this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);//Java窗口的关闭按钮,结束程序
            this.setResizable(false);  //设置窗口不可改变,固定窗口大小
            this.setVisible(true);//设置组件是否显示
            this.repaint();  //java里repaint()是重绘component的方法;
            //它会直接调用下面的方法对界面进行重行绘画
        }//画棋盘界面
        public void paint(Graphics g)
        {
            //双缓冲技术
            BufferedImage buf = new BufferedImage(500, 500, BufferedImage.TYPE_INT_RGB);
            // 这个bufferedImage 可以在网上查找相关用法,它是对图像的一种处理。
            /*
            java.awt.image.BufferedImage是带数据缓冲区的图像类,BuferedImage生成的图片在内存里有一个图像缓冲区,
            利用这个缓冲区我们可以很方便的操作这个图片,通常用来做图片修改操作,如:大小变换、图片变灰、设置图片
            透不透明等。
             */
            Graphics g1 =  buf.createGraphics();  // 创建画笔
            g1.setColor(new Color(0,169,158));
            g1.fill3DRect(43, 60, 375, 375, true);//在窗口中画出一个棋盘
            /*
            fill3DRect(int x,int y,int width,int height,boolean rasied):用预定的颜色填充一个突出显示的矩形。
            x,y是矩形的左上角位置,参数width和height是矩形的宽和高,参数raised是突出与否。
             */
            for (int i = 0; i <= 15; i++) {
                g1.setColor(Color.WHITE);
                g1.drawLine(43, 60+i*25, 375+43, 60+i*25);  //画棋盘横线,15*15的方格棋盘
                g1.drawLine(43+i*25, 60, 43+i*25, 375+60);  //画棋盘竖线
            }
            g1.setFont(new Font("黑体",Font.BOLD,20));
            g1.drawString("游戏信息:"+message,50,50);  //以当前的颜色和字体,(x,y)为左下角,绘制字符串str
    
            g1.drawRect(30, 440, 180, 40);
            g1.drawRect(250, 440, 180, 40);   //画黑方时间与白方时间字符串的边框
            g1.setFont(new Font("宋体",0,12));
    
            g1.drawString("黑方时间: "+blackMessage,40,465);
            g1.drawString("白方时间: "+whiteMessage,260,465);
    
            g1.drawRect(430,66,55,20);
            g1.drawString("重新开始",432,80); //重新开始按钮
    
            g1.drawRect(430,106,55,20);
            g1.drawString("游戏设置",432,120); //游戏设置按钮
    
            g1.drawRect(430,146, 55, 20);
            g1.drawString("游戏说明", 432, 160); // 游戏说明按钮
    
            g1.drawRect(430, 186, 55, 20);
            g1.drawString("退出游戏", 432, 200);  // 退出游戏按钮
    
            g1.drawRect(430, 246, 55, 20);
            g1.drawString("悔棋", 442, 260);  // 悔棋
    
            g1.drawRect(430, 286, 55, 20);
            g1.drawString("认输", 442, 300);  // 认输
    
            g.drawImage(buf, 0, 0,this);
            /*
            public abstract boolean drawImage(Image img,int x,int y,ImageObserver observer)
            显示图像文件img,左上角在(x,y)点。其中observer是用于监听图像创建进度的对象。
             */
    
            public void mousePressed(MouseEvent e){
            if(canPlay){
                x=e.getX();
                y=e.getY();  // 用来获取鼠标坐标
                if(x>55 && x<= 405  && y>=72 && y<=420)      //(55,72),(405,422)分别是左上角圆心和右下角圆心坐标
                {
                    //让鼠标在棋盘范围内
                    if((x-55)%25>12)//取余数,余数是超出整数格的距离。这一步判断鼠标位置超出整数格多少,每半格的距离是12.5
                    {
                        x=(x-55)/25 + 1;//大于半格距离的,在下一格落子。此时x由横坐标变为格子序号
                    }
                    else
                        {
                        x = (x-55)/25;//小于半格的,在本格落子。
                    }
                    if((y-72)%25>12)
                    {
                        y=(y-72)/25 + 1;
                    }
                    else
                        {
                        y=(y-72)/25;
                    }
    
                    /**  (405-55)/25=14格  而棋盘是15*15所以这里需要进行一个判断 12可以进行改动
                     不能超过14就行。
                     这里用的是整形变量,精确度不准,容易造成所点的区域下不了棋
                     2.0版本会升级到把棋子放在交点上,不会在方格内下
                     */
    
    
    
    
                    //落子
                    /**  x,y代表棋子的位置所在
                     chessX,chessY用来记录下棋的位置以便悔棋时需要
                     如  chessX[0] = 3;
                     chessY[0] = 4;
                     即 第一步棋子下在  (3,4)位置
                     */
                    if(allChess[x][y] == 0)//如果无子
                    {
                        chessX[countX++] = x;
                        chessY[countY++] = y;
                        if(isblack)//如果是黑子
                        {
                            allChess[x][y] = 1;//该数组位置保存黑棋
                            isblack = false;//改变变量,轮到白棋落子
                            message = "白方下子";
                        }
                        else
                            {
                            allChess[x][y] = 2;
                            isblack = true;
                            message = "黑方下子";
                        }
                        this.repaint();
                        //调用方法进行绘制,如果allChess[x][y] = 1;  则画出黑棋
    
                        //  下一个棋就进行输赢判断
                        if(this.isWin()){
                            if(allChess[x][y] == 1){
                                JOptionPane.showMessageDialog(this, "游戏结束,黑方胜利");
                            }else {
                                JOptionPane.showMessageDialog(this, "游戏结束,白方胜利");
                            }
                            this.canPlay = false;  //表示游戏结束
                        }
                    }
                }
            }
    
            for(int i=0; i<15; i++){           //数组声明时是行与列的数目,但实际数组是从0开始标记的。
                for (int j = 0; j < 15; j++) {
                    //画实心黑子
                    if(allChess[i][j] == 1){
                        int tempX = i*25+47;
                        int tempY = j*25+64;
                          /*
                        格子边长25,棋子直径16,相差9,一半是4.5,但因为是整型,取4。(43+4,60+4)是左上角棋子相切矩形的
                        左上角坐标
                         */
                        g1.setColor(Color.BLACK);
                        g1.fillOval(tempX, tempY, 16, 16);
                        /*
                        Graphics类的常用方法
                        public abstract void fillOval(int x,int y,int width,int height)
                        在指定的矩形区域内画一个椭圆,并用当前颜色进行填充
                         */
                        g1.setColor(Color.BLACK);
                        g1.drawOval(tempX, tempY, 16, 16);
                        /*
                        Graphics类的常用方法
                        public abstract void drawOval(int x,int y,int width,int height)
                        在指定的矩形区域内画一个椭圆
                         */
                    }
    
                    //画实心白子
                    if(allChess[i][j] == 2){
                        int tempX = i*25+47;
                        int tempY = j*25+64;
                        g1.setColor(Color.WHITE);
                        g1.fillOval(tempX, tempY, 16, 16);
                        g1.setColor(Color.WHITE);
                        g1.drawOval(tempX, tempY, 16, 16);
                    }
                }
            }
            /*
            allChess[i][j]是你下棋的位置, 对这个数组进行判断。如果为1,那就代表是黑棋,2就是白棋。     
               tempX,tempY  是用来确定棋子所在的位置区域的顶点坐标。
               因为一个方格是25*25的大小,所以我们定义一个16*16方格的内切圆,并涂上相应的颜色。
                这样就达到我们在棋盘上的地方进行下棋的目的。
             */
    
            /**
             * 判断输赢规则
             * @return
             */
            public boolean isWin(){
                boolean flag = false;
                int count = 1;  //用来保存共有相同颜色多少棋子相连,初始值为1
                int color = allChess[x][y];  //color = 1 (黑子) color = 2(白子)
    
                //判断横向是否有5个棋子相连,特点:纵坐标是相同,即allChess[x][y] 中y值是相同
                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;
            }
            /**
             * 检查棋盘中的五子棋是否连城五子
             * @param xChange
             * @param yChenge
             * @param color
             * @return
             */
            public int checkCount(int xChange , int yChenge ,int color){
                int count = 1;
                int tempX = xChange;  //xChange、yChenge的值由调用语句传值而来。xChanege即是x的变化量
                int tempy = yChenge;  //保存初始值,tempX和tempY为局部变量
    
                //全局变量x,y最初为鼠标点击的坐标,
                //经下棋方法已经将x,y的范围变成0-15(遍历整个棋盘,寻找相同颜色的棋子)
                while(x + xChange >=0 && x+xChange <15  && y+yChenge >=0 &&
                        y+yChenge < 15 && color == allChess[x+xChange][y+yChenge]){
                    // allChess[x+xChange][y+yChenge] 表示移动一个坐标来进行判断是否为同一颜色
                    //例如横向判断checkCount(1,0,color); 传入xchange = 1,ychange = 0;
                    //   即每次向右移动一次,如果满足同一颜色就继续判断,不满足则返回
    
    
                    count++;
                    if(xChange != 0)  xChange++;     // 满足条件继续向右判断
                    if(yChenge != 0 ){      //  横向判断ychange = 0 不满足条件不执行
                        if(yChenge != 0){
                            if(yChenge > 0) {
                                yChenge++;		//使棋子沿着右下一条线移动,进行判断
                            }else {
                                yChenge--;		// 使棋子沿着右上一条线移动,进行判断
                            }
                        }
                    }
    
                }
    
                //  经过以上判断  xchange和ychange可能发生改变,所以最开始设置初始值以便接下来使用
                xChange = tempX;
                yChenge = tempy;   // 恢复初始值
    
                //以棋子为中心,横向判断为例,分为两个方向,上面是右边判断,下面是进行左边
                while(x-xChange >=0 && x-xChange <15 && y-yChenge >=0 &&
                        y-yChenge <15 && color == allChess[x-xChange][y-yChenge]){
    
                    //(x-xChange >=0 && x-xChange <15 && y-yChenge >=0 &&
                    //  	y-yChenge <15)    始终保持棋子在移动时保持在规定的区域内
    
                    count++;
                    if(xChange != 0){
                        xChange++;
                    }
                    if(yChenge != 0){
                        if (yChenge > 0) {
                            yChenge++;			//使棋子沿着左上一条线移动,进行判断
                        }else {
                            yChenge--;			//使棋子沿着左下一条线移动,进行判断
                        }
                    }
                }
    
                return count;
            }
            /*
             对于横向判断,以你下的棋子为中心,依次向左移动和向右移动一格进行判断,count = this.checkCount(1,0,color);  
             1表示是横坐标,0表示纵坐标,因为只是横向判断所以只需改变横坐标即可。
             (例如所下棋子位置为(5,5),只需判断右边(6,5)的颜色是否一致,
             如若一致继续向右判断,不一致就向左(4,5)依次做出判断)
    
           纵向判断与横向判断同理,但是需要改变纵坐标位置。count = this.checkCount(0,1,color);
    
          以上横纵判断完后如若没有五子相连则继续以棋子为中心右上和左下进行判断,这里的坐标需要进行改动。
            如对于右上进行判断为count = this.checkCount(1,-1,color);    横坐标+1  纵坐标-1。
    
            遍历整个棋盘的思路,就是在每次落子时,在这颗子的各个方向去检查有没有连成五颗相同的棋子。
            而不用每次都从整个棋盘去检查,这样的思路反而不清晰整洁。且随着每颗子落下的位置去检查,
            也恰好与我们日常下棋思考的方式一样。
             */
    
        public static void main(String[] args)
        {
            new FiveGame();
        }
    }
    

    上述代码是自己照着HK云飞的代码,在实现一个一个的功能模块时去梳理的一些记录,并非完整代码。如需参考,见文章顶部的原博文连接。

    在开始时,曾试图自己白手起家。上手才会发现,项目设计开发的过程,远非自己当初的单纯理解。在这里记录下自己在梳理各个功能模块的代码时的一些注释,也是一个保存。不然IDEA里正确代码跑不起来……也是醉了。

    五子棋项目还是比较适合新手入门的,毕竟功能明确,界面简单。基本上只需实现各部分的功能就好。也是通过这项目,再一次理解了面向对象的编程思想。(说的很空,但确实是这么回事儿。)

    设计开发一个五子棋小程序,首先要设计出一个交互界面,简单来说就是画出棋盘和各个功能键的位置。也是第一次知道,java屏幕上的距离单位,是以单个像素为单位的。

    其次陆续实现各部分的功能,先画出棋盘,以及各个功能键的位置,并设置好相关的按钮说明文字。其次,再画出一颗一颗的黑白棋子。

    由于在设计时的问题,这个项目的棋子只能落在小方格内。这就使得各个落点和棋子的画法等涉及到的一系列坐标的设计不一样。此项目的单格长度为25,棋子直径16,且因为int型变量的设置,导致所有的数只能取整型。因而使得棋子在放置的位置上,偏离正方形格的中心,向上向左各0.5个单位。

    其次设计判断输赢的方法(函数),一开始没有思路。后来经同学点拨,考虑是一连串的棋子,在坐标上符合一个函数关系式。但另一个同学指出,函数关系式在判断横纵向的棋子时还算方便,但由于图像在y轴的截距不同,导致判断斜向的连线棋子时会很复杂。于是舍弃该思路。

    参照原作者思路,在判断时分为左右两部分去判断。用一个checkCount函数实现判断。横向坐标,由于借助二维数组的帮助,可转化为向左增减一个单位。纵向同理。斜向连线的判断,可在横坐标增减的同时,对纵坐标进行每次一个单位的增减。从而实现斜向判断的功能。

    把现实世界的东西,虚拟成数字等计算机能理解的简单变量,是一个很有用且需要我好好学习的思想。

    经过这个项目的梳理学习,收获了什么呢……

    1. 变量名称尽量用英文;
    2. 不会的地方就去查;
    3. 有些地方想不通就先放放;
    4. 成为一名程序员的路还有很长……
    5. 自己动手做一下比什么都强;
    6. 思考的过程很重要,实际写代码的过程相比较而言,只是一个简单的实现工作;
    7. 必要时需要经常自己动手在纸上写写画画,才能帮助自己在理解上更容易;
    8. 待续……

    这个项目,只能实现简单的人人对战。上一个台阶的人机对战,我暂时还没有思路。只是简单觉得,需要做一个函数,去判断每个点的概率等等一系列东西。希望下一阶段,可以实现人机对战和更好看的界面。

    未完。

    展开全文
  • 目录 1 摘要 2 Abstract 2 Keywords 2 绪论 3 第一章 相关理论与技术 4 1.1 编程语言 4 ...3.3 设计思路 14 第四章 代码设计 15 4.1游戏运行主程序代码及注释 15 第五章 游戏测试 22 结论 26 参考文献 26
  • JAVA五子棋小游戏

    万次阅读 多人点赞 2018-08-10 18:05:20
    学完Java基础书时总想着要自己编写出小游戏,事情...今天通过这篇文章来分享一下Java五子棋的编写思路。 需要知道五子棋的简单内容,如有棋盘、棋子、输赢规则等需要实现。 为了一步一步讲解,下面的代码将会...

     

    学完Java基础书时总想着要自己编写出小游戏,事情并非如自己所愿,每次鼓起勇气来编写时,总是不知道该怎么写,写到一半就开始放弃。因为自己习惯跟着视屏去看和编写,思路和方法都是老师教,自己根本无法去考虑那么的多,所以一直写不出属于自己的东西。今天通过这篇文章来分享一下Java五子棋的编写思路。

    需要知道五子棋的简单内容,如有棋盘、棋子、输赢规则等需要实现。

    为了一步一步讲解,下面的代码将会进行拆分,方便讲解。    完整代码将会在最下方。

    1.那么我们先来简单的实现一个五子棋的棋盘布局。

    package 模拟练习.五子棋;
    import java.awt.Color;
    import java.awt.Font;
    import java.awt.Graphics;
    import java.awt.Toolkit;
    import java.awt.image.BufferedImage;
    
    import javax.swing.JFrame;
    
    public class FI extends JFrame {
    		//设置游戏界面
    		/*	屏幕分辨率求法:
    				int w = f.getToolkit().getScreenSize().width;//宽度
    				int h = f.getToolkit().getScreenSize().height;//高度
    		Toolkit.getDefaultToolkit().getScreenSize().width   与上面等同
    		都是用来获取屏幕的宽高,
    		this.setLocation((width - 500) / 2 , (height - 500) / 2 );
    		这是使你的窗口能够居中显示,这样看起来美观。
    	*/
    		int width = Toolkit.getDefaultToolkit().getScreenSize().width;
    		int height = Toolkit.getDefaultToolkit().getScreenSize().height;	
    		int[][] allChess = new int[15][15];   // 用数组来保存棋子,0表示无子,1表示黑子,2表示白子
    		boolean isblack = true;   //用来表示黑子还是白子, true表示黑子   false表示白子
    		boolean canPlay = true;   // 用来表示当前游戏是否结束
    		String message = "黑方先行";
    		String blackMessage = "无限制";
    		String whiteMessage = "无限制";	
    		public FI(){
    			this.setTitle("五子棋1.0");
    			this.setSize(500,500);
    			this.setLocation((width - 500) / 2 , (height - 500) / 2 );
    			this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
    			this.setResizable(false);  //设置窗口不可改变,固定窗口大小
    			this.setVisible(true);			
    			this.repaint();  //java里repaint()是重绘component的方法;	
                                //它会直接调用下面的方法对界面进行重行绘画				
    		}
    
    		//画棋盘界面
    		public void paint(Graphics g){
    			//双缓冲技术
    			BufferedImage buf = new BufferedImage(500, 500, BufferedImage.TYPE_INT_RGB);
            // 这个bufferedImage 可以在网上查找相关用法,它是对图像的一种处理。
    			Graphics g1 =  buf.createGraphics();  // 创建画笔
    			g1.setColor(new Color(0,169,158));
    			g1.fill3DRect(43, 60, 375, 375, true);
    			
    				for (int i = 0; i <= 15; i++) {
    					g1.setColor(Color.WHITE);
    					g1.drawLine(43, 60+i*25, 375+43, 60+i*25);  //画棋盘横线
    					g1.drawLine(43+i*25, 60, 43+i*25, 375+60);  //画棋盘竖线
    				}
    				
    				g1.setFont(new Font("黑体",Font.BOLD,20));
    				g1.drawString("游戏信息:"+message,50,50);
    				
    				g1.drawRect(30, 440, 180, 40);
    				g1.drawRect(250, 440, 180, 40);   //画黑方时间与白方时间字符串的边框
    				g1.setFont(new Font("宋体",0,12));
    				
    				    g1.drawString("黑方时间: "+blackMessage,40,465);
    			        g1.drawString("白方时间: "+whiteMessage,260,465);
    			         
    			        g1.drawRect(430,66,55,20);
    			        g1.drawString("重新开始",432,80); //重新开始按钮
    			         
    			        g1.drawRect(430,106,55,20);
    			        g1.drawString("游戏设置",432,120); //游戏设置按钮
    			         
    			        g1.drawRect(430,146, 55, 20);
    			        g1.drawString("游戏说明", 432, 160); // 游戏说明按钮
    			  
    			        g1.drawRect(430, 186, 55, 20);
    			        g1.drawString("退出游戏", 432, 200);  // 退出游戏按钮
    			  
    			        g1.drawRect(430, 246, 55, 20);
    			        g1.drawString("悔棋", 442, 260);  // 悔棋
    			  
    			        g1.drawRect(430, 286, 55, 20);
    			        g1.drawString("认输", 442, 300);  // 认输			
    				
    				 g.drawImage(buf, 0, 0,this);	
    		}
    		
    	public static void main(String[] args) {
    		new FI();
    	}
    }

     这里就简单的实现的窗口和棋盘的布局。(以上实现方法可以用另一种方法进行实现,不用一个一个的画出来,2.0的版本会进行更新   )

    效果图      :五子棋

     2.接下来就开始实现下棋功能,既然要下棋那就要画出棋子。

    	     for(int i=0; i<15; i++){
    				for (int j = 0; j < 15; j++) {
    					//画实心黑子
    					if(allChess[i][j] == 1){    
    						int tempX = i*25+47;
    						int tempY = j*25+64;
    						g1.setColor(Color.BLACK);
    						g1.fillOval(tempX, tempY, 16, 16);
    						g1.setColor(Color.BLACK);
    						g1.drawOval(tempX, tempY, 16, 16);
    					}
    					
    					//画实心白子
    					if(allChess[i][j] == 2){
    						int tempX = i*25+47;
    						int tempY = j*25+64;
    						g1.setColor(Color.WHITE);
    						g1.fillOval(tempX, tempY, 16, 16);
    						g1.setColor(Color.WHITE);
    						g1.drawOval(tempX, tempY, 16, 16);
    					}
    				}
    			}

              allChess[i][j]是你下棋的位置, 对这个数组进行判断  如果为1 那就代表是黑棋
               2就是白棋     

               tempX,tempY  是用来确定棋子所在的位置区域的顶点坐标。
               因为一个方格是25*25的大小     所以我们定义一个16*16方格的内切圆,并涂上相应的颜色
                这样就达到我们在棋盘上的地方进行下棋

    3.接下来是对鼠标进行添加监听器,这样才能做到你点的时候做出相应的反应。

    public void mousePressed(MouseEvent e){
    		if(canPlay){
    			x=e.getX();
    			y=e.getY();  // 用来获取鼠标坐标
    			if(x>55 && x<= 405  && y>=72 && y<=420){
    				//让鼠标在棋盘范围内
    				if((x-55)%25>12){
    					x=(x-55)/25 + 1;
    				}else {
    					x = (x-55)/25;
    				}
    				if((y-72)%25>12){
    					y=(y-72)/25 + 1;
    				}else {
    					y=(y-72)/25;
    				}
    				
                /**  (405-55)/25=14格  而棋盘是15*15所以这里需要进行一个判断 12可以进行改动
                                            不能超过14就行。
                               这里用的是整形变量,精确度不准,容易造成所点的区域下不了棋
                        2.0版本会升级到把棋子放在交点上,不会在方格内下
                  */
    
    
    
    
    				//落子
                            /**  x,y代表棋子的位置所在
                                  chessX,chessY用来记录下棋的位置以便悔棋时需要
                                  如  chessX[0] = 3;
                                      chessY[0] = 4;
                                    即 第一步棋子下在  (3,4)位置
                                */
    				if(allChess[x][y] == 0){
    					chessX[countX++] = x;
    					chessY[countY++] = y;
    					if(isblack){
    						allChess[x][y] = 1;
    						isblack = false;
    						message = "白方下子";
    					}else {
    						allChess[x][y] = 2;
    						isblack = true;
    						message = "黑方下子";
    					}
    					this.repaint();   
             //调用方法进行绘制,如果allChess[x][y] = 1;  则画出黑棋
    					
    
    
                           //  下一个棋就进行输赢判断 
    					if(this.isWin()){
    						if(allChess[x][y] == 1){
    							JOptionPane.showMessageDialog(this, "游戏结束,黑方胜利");
    						}else {
    							JOptionPane.showMessageDialog(this, "游戏结束,白方胜利");
    						}
    						this.canPlay = false;  //表示游戏结束
    					}
    					
    					
    				}
    			}
    		}
    		
    
    	}
    	

          这里是对鼠标的动作所做出的反应,当然重行开始游戏和悔棋等功能也会在这里实现。

    4.接下来是实现对五子棋的输赢做出判断,这个也是比较难的。

              其实思路很简单,就是怎样使得效率提高就有些麻烦了,最容易的方法就是当你下一个棋子时我就开始依次横向和纵向做出判断是否连城五子,以五子棋的颜色为判断基础 ,例如: 横着一排有五个一样的颜色就代表胜利。如果横向和纵向都不符合要求,开始进行斜着判断,直到发现五子相同为止,如果都不成立就代表没有连城五子,不做出任何判断。

    	/**
    	 * 判断输赢规则
    	 * @return
    	 */
    	public boolean isWin(){
    		boolean flag = false;
    		int count = 1;  //用来保存共有相同颜色多少棋子相连,初始值为1
    		int color = allChess[x][y];  //color = 1 (黑子) color = 2(白子)
    		
    		//判断横向是否有5个棋子相连,特点:纵坐标是相同,即allChess[x][y] 中y值是相同
    		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;
    	}
    	/**
    	 * 检查棋盘中的五子棋是否连城五子
    	 * @param xChange
    	 * @param yChenge
    	 * @param color
    	 * @return
    	 */
    	public int checkCount(int xChange , int yChenge ,int color){
    		int count = 1;
    		int tempX = xChange;
    		int tempy = yChenge;  //保存初始值
    		
    		//全局变量x,y最初为鼠标点击的坐标,
    		//经下棋方法已经将x,y的范围变成0-15(遍历整个棋盘,寻找相同颜色的棋子)
    		while(x + xChange >=0 && x+xChange <15  && y+yChenge >=0 && 
    				y+yChenge < 15 && color == allChess[x+xChange][y+yChenge]){
    			// allChess[x+xChange][y+yChenge] 表示移动一个坐标来进行判断是否为同一颜色
    			//例如横向判断checkCount(1,0,color); 传入xchange = 1,ychange = 0;
    			//   即每次向右移动一次,如果满足同一颜色就继续判断,不满足则返回
    			
    			
    			count++;
    			if(xChange != 0)  xChange++;     // 满足条件继续向右判断
    			if(yChenge != 0 ){      //  横向判断ychange = 0 不满足条件不执行
    				if(yChenge != 0){
    					if(yChenge > 0) {   
    						yChenge++;		//使棋子沿着右下一条线移动,进行判断	
    					}else {
    						yChenge--;		// 使棋子沿着右上一条线移动,进行判断
    					}
    				}
    			}
    			
    		}
    		
    		//  经过以上判断  xchange和ychange可能发生改变,所以最开始设置初始值以便接下来使用
    		xChange = tempX;
    		yChenge = tempy;   // 恢复初始值
    		
    		//以棋子为中心,横向判断为例,分为两个方向,上面是右边判断,下面是进行左边
    		while(x-xChange >=0 && x-xChange <15 && y-yChenge >=0 &&
    				y-yChenge <15 && color == allChess[x-xChange][y-yChenge]){
    			
    			//(x-xChange >=0 && x-xChange <15 && y-yChenge >=0 &&
    		//  	y-yChenge <15)    始终保持棋子在移动时保持在规定的区域内
    			
    			count++;
    			if(xChange != 0){
    				xChange++;
    			}
    			if(yChenge != 0){
    				if (yChenge > 0) {
    					yChenge++;			//使棋子沿着左上一条线移动,进行判断
    				}else {
    					yChenge--;			//使棋子沿着左下一条线移动,进行判断
    				}
    			}
    		}
    		
    		return count;
    	}

        对于横向判断,以你下的棋子为中心,依次向左移动和向右移动一格进行判断,count = this.checkCount(1,0,color);  1表示是横坐标,0表示纵坐标,因为只是横向判断所以只需改变横坐标即可。(例如所下棋子位置为(5,5)  只需判断右边(6,5)的颜色是否一致,如若一致继续向右判断,不一致就向左(4,5)依次做出判断)

        纵向判断与横向判断同理,但是需要改变纵坐标位置。count = this.checkCount(0,1,color);

        以上横纵判断完后如若没有五子相连则继续以棋子为中心右上和左下进行判断,这里的坐标需要进行改动。如对于右上进行判断为count = this.checkCount(1,-1,color);    横坐标+1  纵坐标-1。

    以上代码需要你自己多体会,画一个自己一个一个试试,能加深你的理解能力。

    5.做到以上几点就算完成了,接下来实现的是棋盘右边的功能

    //重新开始游戏
    		if(e.getX() >=430 && e.getY() <= (428+55)  && e.getY() >= 66
    			&&	e.getY() <= (66+20) ){
    			int result = JOptionPane.showConfirmDialog(this, "是否重新开始游戏?"); 
    			if(result == 0){
    				restarGame();
    			}
    		}
    
    
    		public void restarGame(){
    			for (int i = 0; i < 15; i++) {
    				for (int j = 0; j < 15; j++) {
    					allChess[i][j] = 0;  //清空棋盘的棋子
    				}
    				
    			}
    			
    			//清空下棋棋子坐标的记录
    			for (int i = 0; i < 15; i++) {
    				chessX[i] = 0;
    				chessY[i] = 0;
    				
    			}
    			
    			countX =0;
    			countY =0;
    			message = "黑方先行";
    			blackMessage = "无限制";
    			whiteMessage = "无限制";
    			blackTime = maxTime;
    			whileTime = maxTime;
    			isblack = true;
    			canPlay = true;
    			this.repaint();
    			
    		}
    	

    这个就是简单的清空棋盘棋子方法,达到重新开局的效果。

    6.还有一个比较不容易理解的是悔棋功能

    	//悔棋
    		if(e.getX() >= 430 && e.getX() <= (430+55) && e.getY() >= 246 
    				&&  e.getY() <= (246+20)){
    			int result = JOptionPane.showConfirmDialog(this, 
    					(isblack == true ? "白方悔棋,黑方是否同意?" :"黑方悔棋,白方是否同意?"));
    			// result = 0为悔棋
    			if(result == 0){
    				allChess[chessX[--countX]][chessY[--countY]]=0;
    				if(isblack == true ){
    					isblack = false;
    				}else {
    					isblack = true;
    				}
    				
    				this.repaint();  //重绘棋盘
    			}
    		}

    (e.getX() >= 430 && e.getX() <= (430+55) && e.getY() >= 246 &&  e.getY() <= (246+20)  表示鼠标所点击的位置在这个范围表示悔棋。  这里其实可以用  button按钮来代替的

    先进行判断是否愿意悔棋,当确定实现悔棋时,即实现allChess[chessX[--countX]][chessY[--countY]]=0;这个功能,因为chessx[]和chessY[]用来记录你所下的步数,例如:你下到第11步时想要悔棋,这时将allChess[][]将其置0并消除第11步数字,表示没有下棋;这时轮到你下棋。这就是悔棋的原理。

    总结:以上就是对五子棋的简单实现,由于还没有接触到多线程,所以对功能进行了部分删减,这只是V1.0版本,后续将会继续增加一些新的功能。其次这个代码也并不是我原创的,只能说照着编一下吧,拿来供自己琢磨。对于学习Java有一些小小的建议,希望大家学习的时候不要总是直接复制粘贴,这样对你没多少提升,就算你原原本本照着编一下也会对你有所提升。写这篇文章也只是想分享一下自己学习,提升自己的逻辑思维。

    完整代码:

    package 模拟练习.五子棋;
    import javax.swing.JFrame;
    import javax.swing.JOptionPane;
    import java.awt.*;
    import java.awt.event.MouseEvent;
    import java.awt.event.MouseListener;
    import java.awt.image.BufferedImage;
    public  class FiveGame extends JFrame implements MouseListener{
    	
    	private static final long serialVersionUID = 1L;
    	//设置游戏界面
    	//	屏幕分辨率求法:
    	//		int w = f.getToolkit().getScreenSize().width;//宽度
    	//		int h = f.getToolkit().getScreenSize().height;//高度
    	int width = Toolkit.getDefaultToolkit().getScreenSize().width;
    	int height = Toolkit.getDefaultToolkit().getScreenSize().height;
    	
    	int x,y;  // 定义鼠标的坐标
    	int[][] allChess = new int[15][15];   // 用数组来保存棋子,0表示无子,1表示黑子,2表示白子
    	boolean isblack = true;   //用来表示黑子还是白子, true表示黑子   false表示白子
    	boolean canPlay = true;   // 用来表示当前游戏是否结束
    	String message = "黑方先行";
    	String blackMessage = "无限制";
    	String whiteMessage = "无限制";
    	
    	//保存棋谱,记录双方每一步落子的位置
    	int[] chessX = new int[255];
    	int[] chessY = new int[255];
    	int countX,countY;
    	
    	//默认设置无时间限制
    	int maxTime = 0;   //保存最大时间
    	int blackTime = 0;
    	int whileTime = 0;   //保存黑白方所剩余的时间
    
    	public FiveGame(){
    		this.setTitle("五子棋1.0");
    		this.setSize(500,500);
    		this.setLocation((width - 500) / 2 , (height - 500) / 2 );
    		this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
    		this.setResizable(false);  //设置窗口不可改变,固定窗口大小
    		this.setVisible(true);
    		
    		this.repaint();  //java里repaint()是重绘component的方法;
    		this.addMouseListener(this);
    
    		
    	}
    	
    	//画棋盘界面
    	public void paint(Graphics g){
    		//双缓冲技术
    		BufferedImage buf = new BufferedImage(500, 500, BufferedImage.TYPE_INT_RGB);
    		Graphics g1 =  buf.createGraphics();  // 创建画笔
    		g1.setColor(new Color(0,169,158));
    		g1.fill3DRect(43, 60, 375, 375, true);
    		
    			for (int i = 0; i <= 15; i++) {
    				g1.setColor(Color.WHITE);
    				g1.drawLine(43, 60+i*25, 375+43, 60+i*25);  //画棋盘横线
    				g1.drawLine(43+i*25, 60, 43+i*25, 375+60);  //画棋盘竖线
    			}
    			
    			g1.setFont(new Font("黑体",Font.BOLD,20));
    			g1.drawString("游戏信息:"+message,50,50);
    			
    			g1.drawRect(30, 440, 180, 40);
    			g1.drawRect(250, 440, 180, 40);   //画黑方时间与白方时间字符串的边框
    			g1.setFont(new Font("宋体",0,12));
    			
    			    g1.drawString("黑方时间: "+blackMessage,40,465);
    		        g1.drawString("白方时间: "+whiteMessage,260,465);
    		         
    		        g1.drawRect(430,66,55,20);
    		        g1.drawString("重新开始",432,80); //重新开始按钮
    		         
    		        g1.drawRect(430,106,55,20);
    		        g1.drawString("游戏设置",432,120); //游戏设置按钮
    		         
    		        g1.drawRect(430,146, 55, 20);
    		        g1.drawString("游戏说明", 432, 160); // 游戏说明按钮
    		  
    		        g1.drawRect(430, 186, 55, 20);
    		        g1.drawString("退出游戏", 432, 200);  // 退出游戏按钮
    		  
    		        g1.drawRect(430, 246, 55, 20);
    		        g1.drawString("悔棋", 442, 260);  // 悔棋
    		  
    		        g1.drawRect(430, 286, 55, 20);
    		        g1.drawString("认输", 442, 300);  // 认输
    		
    		        
    		     for(int i=0; i<15; i++){
    				for (int j = 0; j < 15; j++) {
    					//画实心黑子
    					if(allChess[i][j] == 1){    
    						int tempX = i*25+47;
    						int tempY = j*25+64;
    						g1.setColor(Color.BLACK);
    						g1.fillOval(tempX, tempY, 16, 16);
    						g1.setColor(Color.BLACK);
    						g1.drawOval(tempX, tempY, 16, 16);
    					}
    					
    					//画实心白子
    					if(allChess[i][j] == 2){
    						int tempX = i*25+47;
    						int tempY = j*25+64;
    						g1.setColor(Color.WHITE);
    						g1.fillOval(tempX, tempY, 16, 16);
    						g1.setColor(Color.WHITE);
    						g1.drawOval(tempX, tempY, 16, 16);
    					}
    				}
    			}
    		
    			
    			 g.drawImage(buf, 0, 0,this);	
    	}
    	
    	
    	
    	public void mousePressed(MouseEvent e){
    		if(canPlay){
    			x=e.getX();
    			y=e.getY();  // 用来获取鼠标坐标
    			if(x>55 && x<= 405  && y>=72 && y<=420){
    				//让鼠标在棋盘范围内
    				if((x-55)%25>12){
    					x=(x-55)/25 + 1;
    				}else {
    					x = (x-55)/25;
    				}
    				if((y-72)%25>12){
    					y=(y-72)/25 + 1;
    				}else {
    					y=(y-72)/25;
    				}
    				
    				//落子
    				if(allChess[x][y] == 0){
    					chessX[countX++] = x;
    					chessY[countY++] = y;
    					if(isblack){
    						allChess[x][y] = 1;
    						isblack = false;
    						message = "白方下子";
    					}else {
    						allChess[x][y] = 2;
    						isblack = true;
    						message = "黑方下子";
    					}
    					this.repaint();
    					
    					if(this.isWin()){
    						if(allChess[x][y] == 1){
    							JOptionPane.showMessageDialog(this, "游戏结束,黑方胜利");
    						}else {
    							JOptionPane.showMessageDialog(this, "游戏结束,白方胜利");
    						}
    						this.canPlay = false;  //表示游戏结束
    					}
    					
    					
    				}
    			}
    		}
    		
    		//重新开始游戏
    		if(e.getX() >=430 && e.getY() <= (428+55)  && e.getY() >= 66
    			&&	e.getY() <= (66+20) ){
    			int result = JOptionPane.showConfirmDialog(this, "是否重新开始游戏?"); 
    			if(result == 0){
    				restarGame();
    			}
    		}
    		
    		
    		//游戏说明
    		if(e.getX() >= 430 && e.getY() <= (430+55)  && e.getY() >=146
    			&&	e.getY() <= (146+20) ){
    			JOptionPane.showMessageDialog(this, "规则:横竖斜先连成五子者获胜!");
    		}
    		
    		//退出游戏
    		if(e.getX() >=430 && e.getX() <= (430+55)  && e.getY() >=186 
    				&&  e.getY() <= (186+20)){
    			int result = JOptionPane.showConfirmDialog(this, "是否退出游戏?");
    			if(result == 0){
    				System.exit(0);
    			}
    		}
    		
    		//悔棋
    		if(e.getX() >= 430 && e.getX() <= (430+55) && e.getY() >= 246 
    				&&  e.getY() <= (246+20)){
    			int result = JOptionPane.showConfirmDialog(this, 
    					(isblack == true ? "白方悔棋,黑方是否同意?" :"黑方悔棋,白方是否同意?"));
    			// result = 0为悔棋
    			if(result == 0){
    				allChess[chessX[--countX]][chessY[--countY]]=0;
    				if(isblack == true ){
    					isblack = false;
    				}else {
    					isblack = true;
    				}
    				
    				this.repaint();  //重绘棋盘
    			}
    		}
    		
    		 //认输
            if(e.getX()>=430 && e.getX()<=(428+55) && e.getY()>=286 
            		&& e.getY()<=(286+20)){
                int result=JOptionPane.showConfirmDialog(this, "是否认输?");
                if(result==0){
                    JOptionPane.showMessageDialog(this,
                    	"游戏结束,"+(isblack==true ? "黑方认输,白方获胜!" : "白方认输,黑方获胜!"));
                }
            }
    
    	}
    	
    		public void restarGame(){
    			for (int i = 0; i < 15; i++) {
    				for (int j = 0; j < 15; j++) {
    					allChess[i][j] = 0;  //清空棋盘的棋子
    				}
    				
    			}
    			
    			//清空下棋棋子坐标的记录
    			for (int i = 0; i < 15; i++) {
    				chessX[i] = 0;
    				chessY[i] = 0;
    				
    			}
    			
    			countX =0;
    			countY =0;
    			message = "黑方先行";
    			blackMessage = "无限制";
    			whiteMessage = "无限制";
    			blackTime = maxTime;
    			whileTime = maxTime;
    			isblack = true;
    			canPlay = true;
    			this.repaint();
    			
    		}
    	
    	
    
    	/**
    	 * 判断输赢规则
    	 * @return
    	 */
    	public boolean isWin(){
    		boolean flag = false;
    		int count = 1;  //用来保存共有相同颜色多少棋子相连,初始值为1
    		int color = allChess[x][y];  //color = 1 (黑子) color = 2(白子)
    		
    		//判断横向是否有5个棋子相连,特点:纵坐标是相同,即allChess[x][y] 中y值是相同
    		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;
    	}
    	/**
    	 * 检查棋盘中的五子棋是否连城五子
    	 * @param xChange
    	 * @param yChenge
    	 * @param color
    	 * @return
    	 */
    	public int checkCount(int xChange , int yChenge ,int color){
    		int count = 1;
    		int tempX = xChange;
    		int tempy = yChenge;  //保存初始值
    		
    		//全局变量x,y最初为鼠标点击的坐标,
    		//经下棋方法已经将x,y的范围变成0-15(遍历整个棋盘,寻找相同颜色的棋子)
    		while(x + xChange >=0 && x+xChange <15  && y+yChenge >=0 && 
    				y+yChenge < 15 && color == allChess[x+xChange][y+yChenge]){
    	
    			count++;
    			if(xChange != 0)  xChange++;    
    			if(yChenge != 0 ){      
    				if(yChenge != 0){
    					if(yChenge > 0) {   
    						yChenge++;		
    					}else {
    						yChenge--;		
    					}
    				}
    			}
    			
    		}
    		
    		
    		xChange = tempX;
    		yChenge = tempy;   // 恢复初始值
    		
    		
    		while(x-xChange >=0 && x-xChange <15 && y-yChenge >=0 &&
    				y-yChenge <15 && color == allChess[x-xChange][y-yChenge]){		
    			count++;
    			if(xChange != 0){
    				xChange++;
    			}
    			if(yChenge != 0){
    				if (yChenge > 0) {
    					yChenge++;			
    				}else {
    					yChenge--;			
    				}
    			}
    		}
    		
    		return count;
    	}
    	
    	
    
    	public void mouseClicked(MouseEvent e) {
    		// TODO Auto-generated method stub
    		
    	}
    
    	public void mouseReleased(MouseEvent e) {
    		// TODO Auto-generated method stub
    		
    	}
    
    	public void mouseEntered(MouseEvent e) {
    		// TODO Auto-generated method stub
    		
    	}
    
    	public void mouseExited(MouseEvent e) {
    		// TODO Auto-generated method stub
    		
    	}
    	
    	public static void main(String[] args) {
    		new FiveGame();
    	}
    
    	
    }
    

    里面可能存在一些瑕疵,不过后续版本会进行修改。

    如若存在什么问题请联系我进行修改,你的建议将会是我最大的动力

     

    展开全文
  • java 五子棋之人机对战思路详解

    千次阅读 多人点赞 2013-07-06 21:24:58
    最近做了五子棋,记录下自己完成五子棋的人机对战的思路。  首先,思路是这样的:每当人手动下一颗棋子(黑子)的时候,应当遍历它周围棋子的情况,并赋予周围棋子一定的权值,当在机器要下棋子(白子)守护之前...

        最近做了五子棋,记录下自己完成五子棋的人机对战的思路。


        首先,思路是这样的:每当人手动下一颗棋子(黑子)的时候,应当遍历它周围棋子的情况,并赋予周围棋子一定的权值,当在机器要下棋子(白子)守护之前,会遍历整个棋盘的权值情况(棋盘的权值存在一个二维数组中),从中找出权值最大的点坐标,并下子(白子)。


        这样的话,问题就集中在两个方面了,一个是:如何遍历黑子周围的棋子情况? 另一个是:如何设定权值?


        首先,是设定权值。这个没有固定的设定方案,可以先试着设定,然后,尝试效果后(主要是白子的攻防情况是否合理),再调整。

        以下是我的设定方案:


       


        接着,是相对困难的部分,就是如何遍历黑子周围的棋子情况。 从之前权值方案中可以看到,设置权值的一个很重要的目的是为了进行防守,所以应当在连续黑子的两端(下面图中的橙色区域)设置权值,这样就有利于白子填充在连续黑子的两端,从而达到防守的目的,下面这张图可以说明:

        

        中心的黑子:表示当前所下的黑子,周围的棋子表示是之前下的。

        红色箭头:表示需要遍历的八个方向,因为中心黑子的坐标(i, j)是已知的,所以很容易得到周围的棋子坐标(i+n, j+m)

        橙色方框:表示连续黑子的末端,可能是空白(表示还没有棋子填充),也可能是白子。


        接着是算法思想:

        首先,应当先判断敌方棋子(黑子)第一次下的时候(敌方棋子先下),此时,周围八个棋子都是空的,于是应当对周围八个点赋予相同的权值(活一),当遍历整个棋盘后,便在这八个点中随机选择一个(用随机数),填上黑子。


        接着,敌方继续下子,如果敌方当前所下棋子与之前的棋子连续,则会构成活二或者眠二(以此类推,会构成活三眠三~~,这时,根据权值表,会赋予周围棋子更大的权值(权值应当是累加的,也就是说,当前权值 += 之前权值),最后遍历后,下白子。




    展开全文
  • java课程设计五子棋游戏.doc 五子棋小游戏1.课程设计的目的 2.设计方案论证 文本文档格式的
  • java五子棋代码设计 完成面板 创建一个类Panel用于创建面板 package com.ningmeng; import javax.swing.*; import java.awt.*; //面板 public class Panel extends JFrame { //创建面板 Panel(){ setVisible...

    java五子棋代码设计

    完成面板

    创建一个类Panel用于创建面板

    package com.ningmeng;
    
    import javax.swing.*;
    import java.awt.*;
    
    //面板
    public class Panel extends JFrame {
        //创建面板
        Panel(){
            setVisible(true);//显示窗口
            this.setTitle("欢迎来到柠檬的五子棋游戏");//标题
            this.setSize(600,700);//设置窗口大小
            this.setResizable(false);//禁止改变大小
            this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);//关闭窗口退出程序
            JPanel jPanel = new JPanel();//创建面板组件
            JLabel jlabel = new JLabel("鼠标左键下棋,右键悔棋");//创建文本
            jPanel.add(jlabel);//将文本放入面板组件里
            this.add(jPanel,BorderLayout.NORTH);//将面板组件放入JFrame
    
        }
    
        public static void main(String[] args) {
            new Panel();
        }
    }
    

    在这里插入图片描述

    设置开始按钮和提示文字

    新建一个类Checkerboard用于绘制棋盘

    package com.ningmeng;
    
    import javax.swing.*;
    //棋盘
    //绘画的话需要继承JPanel 
    public class Checkerboard extends JPanel  {
        //定义重置按钮
        JButton button = new JButton("重置");
        //设置文本内容(用来显示谁来下棋)
        JLabel jLabel_1 = new JLabel("请黑棋下子");
        //设置文本内容(用来显示输赢)
        JLabel  jLabel_2 = new JLabel("加油哦!!!");
        //构造函数
        Checkerboard(){
            this.setSize(500, 500);//设置大小
            this.setLayout(null);//设置布局(绝对布局)
            this.add(button);//添加按钮到容器
            this.button.setBounds(130, 10, 70, 30);//设置在容器中的坐标和大小
            this.add(jLabel_1);//添加文本到容器
            jLabel_1.setBounds(230, 10, 100, 30);//设置在容器中的坐标和大小
            this.add(jLabel_2);//添加文本到容器
            jLabel_2.setBounds(320, 10, 100, 30);//设置在容器中的坐标和大小
        }
    }
    

    将该内加到面板

    package com.ningmeng;
    
    import javax.swing.*;
    import java.awt.*;
    
    //面板
    public class Panel extends JFrame {
        //创建面板
        Panel(){
            setVisible(true);//显示窗口
            this.setTitle("欢迎来到柠檬的五子棋游戏");//标题
            this.setSize(600,700);//设置窗口大小
            this.setResizable(false);//禁止改变大小
            this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);//关闭窗口退出程序
            JPanel jPanel = new JPanel();//创建面板组件
            JLabel jlabel = new JLabel("鼠标左键下棋,右键悔棋");//创建文本
            jPanel.add(jlabel);//将文本放入面板组件里
            this.add(jPanel,BorderLayout.NORTH);//将面板组件放入JFrame
            //下面为添加的代码部分
            
            Checkerboard checkerboard = new Checkerboard();//实例化Checkerboard类
            add(checkerboard);//将创建好的
            checkerboard.setBounds(70, 90, 440, 440);//设置在容器中的坐标和大小
            ///
        }
    
        public static void main(String[] args) {
            new Panel();
        }
    }
    

    在这里插入图片描述

    添加网格

    在Panel里添加下面的方法

    /**
     * 创建 Paint类(为画笔类)
     * @param g Graphics这个可以理解为笔
     * 这里记一下五指棋的格子是15*15的
     */
    public void paint(Graphics g) {
        super.paint(g);//调用父类函数
        //绘制横线
        for (int i = 80; i <= 380; i = i + 20) {
            g.drawLine(120, i, 420, i);//划线
        }
        //绘制竖线
        for (int j = 120; j <= 420; j = j + 20) {
            g.drawLine(j, 80, j, 380);//划线
        }
        //画点
        g.fillOval(257, 217, 6, 6);//中间
        g.fillOval(177, 137, 6, 6);//左上
        g.fillOval(357, 137, 6, 6);//右上
        g.fillOval(177, 317, 6, 6);//左下
        g.fillOval(357, 317, 6, 6);//右下
    }
    

    在这里插入图片描述

    实现下棋

    首先我们可以先设置一个颜色,比如黑棋为1白棋为-1,默认为黑棋就是1。这样我们下了黑棋传递-1,让-1*1=-1也就是下白棋。
    我们先定义出2个棋子
    棋子只能在棋盘中那么棋子的位置怎么计算呢?

    //用输出语句的方法可以知道现在表格左上点的位置为119和77
    //用输出语句的方法可以知道现在表格右下点的位置为419和378
    System.out.println("x="+x);
    System.out.println("y="+y)
    

    白棋

    package com.ningmeng;
    
    import java.awt.*;
    import java.awt.event.InputEvent;
    import java.awt.event.MouseEvent;
    import java.awt.event.MouseListener;
    
    //白棋 继承绘图类 实现鼠标监听接口
    public class ChessPointWhite extends Canvas  implements MouseListener {
        //实例化棋盘
        Checkerboard checkerboard;
        //构造方法 定义旗子
        ChessPointWhite(){
            this.addMouseListener(this);//设置监听
        }
        //制作白棋
        public void paint(Graphics g) {
            g.setColor(Color.white);//设置白棋颜色
            g.fillOval(0, 0, 20, 20);//设置白棋的大小
        }
    
        public void mouseClicked(MouseEvent e) {
    
        }
        //鼠标按键在组件上按下时调用
        public void mousePressed(MouseEvent e) {
            //判断是不是鼠标左击
            if (e.getModifiers() == InputEvent.BUTTON3_MASK) {
                checkerboard.remove(this);//在棋盘中移除白棋组件
                checkerboard.color = 1;//设置黑棋
                checkerboard.jLabel_1.setText("请白棋下棋");//设置提示文字
            }
        }
    
        public void mouseReleased(MouseEvent e) {
    
        }
    
        public void mouseEntered(MouseEvent e) {
    
        }
    
        public void mouseExited(MouseEvent e) {
    
        }
    }
    

    黑棋

    package com.ningmeng;
    
    import java.awt.*;
    import java.awt.event.InputEvent;
    import java.awt.event.MouseEvent;
    import java.awt.event.MouseListener;
    
    //黑棋 继承绘图类 实现鼠标监听接口
    public class ChessPointBlack extends Canvas implements MouseListener {
        //实例化棋盘
        Checkerboard checkerboard;
        //构造方法 定义旗子
        ChessPointBlack(){
            addMouseListener(this);//设置监听
        }
    
        //制作黑棋
        public void paint(Graphics g) {
            g.setColor(Color.black);//设置黑棋颜色
            g.fillOval(0, 0, 20, 20);//设置黑棋的大小
        }
    
        public void mouseClicked(MouseEvent e) {
    
        }
        //鼠标按键在组件上按下时调用
        public void mousePressed(MouseEvent e) {
            //判断是不是鼠标左击
            if (e.getModifiers() == InputEvent.BUTTON3_MASK) {
                checkerboard.remove(this);//在棋盘中移除黑棋组件
                checkerboard.color = -1;//设置白棋
                checkerboard.jLabel_1.setText("请黑棋下棋");//设置提示文字
            }
        }
    
        public void mouseReleased(MouseEvent e) {
    
        }
    
        public void mouseEntered(MouseEvent e) {
    
        }
    
        public void mouseExited(MouseEvent e) {
    
        }
    }
    

    下棋

    在ChessPointWhite里实现接口MouseListener,并且构造方法里设置监听,重写mousePressed方法,在构造函数里设置监听

    package com.ningmeng;
    
    import javax.swing.*;
    import java.awt.*;
    import java.awt.event.*;
    
    //棋盘
    //绘画的话需要继承JPanel 鼠标监听MouseListener 
    public class Checkerboard extends JPanel implements MouseListener {
    
        //定义重置按钮
        JButton button = new JButton("重置");
        //设置文本内容(用来显示谁来下棋)
        JLabel jLabel_1 = new JLabel("请黑棋下子");
        //设置文本内容(用来显示输赢)
        JLabel  jLabel_2 = new JLabel("加油哦!!!");
        int color = 1;//设置棋的颜色默认为黑棋
        int x,y;//设置鼠标点击的默认位置
        //构造函数
        Checkerboard(){
            this.setSize(500, 500);//设置大小
            this.setLayout(null);//设置布局(绝对布局)
            this.add(button);//添加按钮到容器
            this.button.setBounds(130, 10, 70, 30);//设置在容器中的坐标和大小
            this.add(jLabel_1);//添加文本到容器
            jLabel_1.setBounds(230, 10, 100, 30);//设置在容器中的坐标和大小
            this.add(jLabel_2);//添加文本到容器
            jLabel_2.setBounds(320, 10, 100, 30);//设置在容器中的坐标和大小
            //设置监听
            addMouseListener(this);
        }
    
        /**
         * 创建 Paint类(为画笔类)
         * @param g Graphics这个可以理解为笔
         * 这里记一下五指棋的格子是15*15的
         */
        public void paint(Graphics g) {
            super.paint(g);//调用父类函数
            //绘制横线
            for (int i = 80; i <= 380; i = i + 20) {
                g.drawLine(120, i, 420, i);//划线
            }
            //绘制竖线
            for (int j = 120; j <= 420; j = j + 20) {
                g.drawLine(j, 80, j, 380);//划线
            }
            //画点
            g.fillOval(257, 217, 6, 6);//中间
            g.fillOval(177, 137, 6, 6);//左上
            g.fillOval(357, 137, 6, 6);//右上
            g.fillOval(177, 317, 6, 6);//左下
            g.fillOval(357, 317, 6, 6);//右下
        }
    
        //鼠标按键在组件上按下时调用。
        public void mousePressed(MouseEvent e) {
            //判断鼠标是否为单击
            if (e.getModifiers() == InputEvent.BUTTON1_MASK) {
                //x和y和起来代表鼠标点击的位置
                x = e.getX();//获取鼠标点击的x位置
                y = e.getY();//获取鼠标点击的y位置
                //实例化出黑棋和白棋
                ChessPointBlack black = new ChessPointBlack();
                ChessPointWhite white = new ChessPointWhite();
                //设置下棋的范围
                if (x < 119 || y <77 || x > 419 || y > 378) {
                } else {
                    if (color == 1) {
                        //添加黑棋
                        this.add(black);
                        //设置黑棋位置
                        black.setBounds((x + 10) / 20 * 20 - 10, (y + 10) / 20 * 20 - 10, 20, 20);
                        //设置为白棋
                        color = color * (-1);
                        //修改提示位置
                        jLabel_1.setText("请白棋下子");
                    } else if (color == -1) {
                        //添加白棋
                        this.add(white);
                        //设置白棋位置
                        white.setBounds((x + 10) / 20 * 20 - 10, (y + 10) / 20 * 20 - 10, 20, 20);
                        //设置为黑棋
                        color = color * (-1);
                        jLabel_1.setText("请黑棋下子");
    
                    }
                }
            }
        }
    
    
        public void mouseClicked(MouseEvent e) {
        }
    
        public void mouseReleased(MouseEvent e) {
    
        }
    
        public void mouseEntered(MouseEvent e) {
    
        }
    
        public void mouseExited(MouseEvent e) {
    
        }
    }
    

    在这里插入图片描述

    判断输赢的方法

    定义游戏开始和结束的标记和存放棋子的数组,下棋之后需要保持棋子的位置和判断输赢。

    下面为修改好的代码

    package com.ningmeng;
    
    import javax.swing.*;
    import java.awt.*;
    import java.awt.event.*;
    
    //棋盘
    //绘画的话需要继承JPanel 鼠标监听MouseListener 事件ActionListener
    public class Checkerboard extends JPanel implements MouseListener {
    
        //定义重置按钮
        JButton button = new JButton("重置");
        //设置文本内容(用来显示谁来下棋)
        JLabel jLabel_1 = new JLabel("请黑棋下子");
        //设置文本内容(用来显示输赢)
        JLabel  jLabel_2 = new JLabel("加油哦!!!");
        int color = 1;//设置棋的颜色默认为黑棋
        int x,y;//设置鼠标点击的默认位置
    
        int[][] allChess = new int[25][25];//定义数组存放棋子
        boolean flag = false;//定义一个游戏结束和开始的标记
        //构造函数
        Checkerboard(){
            this.setSize(500, 500);//设置大小
            this.setLayout(null);//设置布局(绝对布局)
            this.add(button);//添加按钮到容器
            this.button.setBounds(130, 10, 70, 30);//设置在容器中的坐标和大小
            this.add(jLabel_1);//添加文本到容器
            jLabel_1.setBounds(230, 10, 100, 30);//设置在容器中的坐标和大小
            this.add(jLabel_2);//添加文本到容器
            jLabel_2.setBounds(320, 10, 100, 30);//设置在容器中的坐标和大小
            //设置监听
            addMouseListener(this);
        }
    
        /**
         * 创建 Paint类(为画笔类)
         * @param g Graphics这个可以理解为笔
         * 这里记一下五指棋的格子是15*15的
         */
        public void paint(Graphics g) {
            super.paint(g);//调用父类函数
            //绘制横线
            for (int i = 80; i <= 380; i = i + 20) {
                g.drawLine(120, i, 420, i);//划线
            }
            //绘制竖线
            for (int j = 120; j <= 420; j = j + 20) {
                g.drawLine(j, 80, j, 380);//划线
            }
            //画点
            g.fillOval(257, 217, 6, 6);//中间
            g.fillOval(177, 137, 6, 6);//左上
            g.fillOval(357, 137, 6, 6);//右上
            g.fillOval(177, 317, 6, 6);//左下
            g.fillOval(357, 317, 6, 6);//右下
        }
    
        //鼠标按键在组件上按下时调用。
        public void mousePressed(MouseEvent e) {
            if(flag){ //如果为true 游戏结束无法下棋
                return;
            }
            //判断鼠标是否为单击
            if (e.getModifiers() == InputEvent.BUTTON1_MASK) {
                //x和y和起来代表鼠标点击的位置
                x = e.getX();//获取鼠标点击的x位置
                y = e.getY();//获取鼠标点击的y位置
                //实例化出黑棋和白棋
                ChessPointBlack black = new ChessPointBlack();
                ChessPointWhite white = new ChessPointWhite();
                //设置下棋的范围
                if (x < 119 || y <77 || x > 419 || y > 378) {
                } else {
                    if (color == 1) {
                        //添加黑棋
                        this.add(black);
                        //设置黑棋位置
                        black.setBounds((x + 10) / 20 * 20 - 10, (y + 10) / 20 * 20 - 10, 20, 20);
                        //设置为白棋
                        color = color * (-1);
                        //修改提示位置
                        jLabel_1.setText("请白棋下子");
                    } else if (color == -1) {
                        //添加白棋
                        this.add(white);
                        //设置白棋位置
                        white.setBounds((x + 10) / 20 * 20 - 10, (y + 10) / 20 * 20 - 10, 20, 20);
                        //设置为黑棋
                        color = color * (-1);
                        jLabel_1.setText("请黑棋下子");
                    }
                    flag = save(x, y, color);//保存棋子判断输赢
                }
            }
        }
       
        //保存下过的棋子
        public boolean save(int x, int y,int color){
            //计算x和y的位置(这里不能直接用鼠标点击的位置,将x和y设置25的范围内,并且不能为小数)
            x = (int) Math.round((x - 40)/20.0);
            y = (int) Math.round((y - 40)/20.0);
            allChess[x][y] = color;//保存棋子
            boolean flag = checkWin(x,y);//调用判断输赢的方法
            if(flag == true){
                if(color == 1){
                    jLabel_2.setText("白棋胜利!!!");
                }else{
                    jLabel_2.setText("黑棋胜利!!!");
                }
    
                return true;
    
            }
            return false;
    
        }
        private boolean checkWin(int x,int y) {
            boolean flag = false; //判断输赢的时候默认为false
            int count = 1;// 保存共有相同颜色多少棋子相连 默认为一个
            int color = allChess[x][y];//保存棋子的数组 根据x和y可以取出棋子的颜色
            // 判断横向是否有5个棋子相连,特点 纵坐标 是相同, 即allChess[x][y]中y值是相同(下面的方法思路一样)
            // 通过循环来做棋子相连的判断
            // 横向的判断
            int i = 1;
            //判断向左边加棋子
            while (color == allChess[x + i][y]) {
                count++;
                i++;
            }
            //判断向右边加棋子
            i = 1;
            while (x-i >= 0 && color == allChess[x - i][y]) {
                count++;
                i++;
            }
            //大于大于5获胜
            if (count >= 5) {
                flag = true;
            }
    
            // 纵向的判断
            int i2 = 1;
            int count2 = 1;
            //判断向上下棋
            while (color == allChess[x][y + i2]) {
                count2++;
                i2++;
            }
    
            i2 = 1;
            //判断向上下棋
            while (y >= i2  && color == allChess[x][y - i2]) {
                count2++;
                i2++;
            }
            //判断输赢
            if (count2 >= 5) {
                flag = true;
            }
    
            // 斜方向的判断(右上 + 左下)
            int i3 = 1;
            int count3 = 1;
            //判断左下
            while (y >= i3 && color == allChess[x + i3][y - i3]) {
                count3++;
                i3++;
            }
            //判断右上
            i3 = 1;
            while (x >= i3 && color == allChess[x - i3][y + i3]) {
                count3++;
                i3++;
            }
            //判断输赢
            if (count3 >= 5) {
                flag = true;
            }
            // 斜方向的判断(右下 +左上)
            int i4 = 1;
            int count4 = 1;
            //判断左上
            while (color == allChess[x + i4][y + i4]) {
                count4++;
                i4++;
            }
            i4 = 1;
            //判断右下
            while (x >= i4 && y >= i4 && color == allChess[x - i4][y - i4]) {
                count4++;
                i4++;
            }
            //判断输赢
            if (count4 >= 5) {
                flag = true;
            }
            return flag;
        }
    
        public void mouseClicked(MouseEvent e) {
        }
    
        public void mouseReleased(MouseEvent e) {
    
        }
    
        public void mouseEntered(MouseEvent e) {
    
        }
    
        public void mouseExited(MouseEvent e) {
    
        }
    }
    

    在这里插入图片描述

    重置按钮

    在ChessPointWhite里实现接口ActionListener,并且构造方法里设置监听,重写actionPerformed方法

    并且同样在构造函数里设置按钮监听,内容和上面基本一致就复制部分代码了

    //设置按钮监听
    button.addActionListener(this);
    
    //重置按钮
    public void actionPerformed(ActionEvent e) {
        this.removeAll();//移除所有
        color = 1;//设置为黑棋
        this.add(button);//添加按钮到容器
        this.button.setBounds(130, 10, 70, 30);//设置在容器中的坐标和大小
        this.add(jLabel_1);//添加文本到容器
        jLabel_1.setBounds(230, 10, 100, 30);//设置在容器中的坐标和大小
        this.add(jLabel_2);//添加文本到容器
        jLabel_2.setBounds(320, 10, 100, 30);//设置在容器中的坐标和大小
        jLabel_1.setText("请黑棋下子");//设置提示文字
        jLabel_2.setText("加油哦!!!");//设置提示文字
    }
    

    源码地址
    链接:https://pan.baidu.com/s/1CE-v0NdmEODS0bStuufCmQ
    提取码:tc29
    复制这段内容后打开百度网盘手机App,操作更方便哦

    展开全文
  • 我一哥们也是做Java开发,暂且先叫他峰哥吧,到今年已经入行6年了,每天还是写一些业务代码,至今还是个单身狗,愁的头发真的都快谢顶了。 虽然峰哥每天做着CRUD的工作,但每天还是做着能进BAT的梦,尤其是今年,...
  • Java五子棋最全教程

    2021-03-15 15:46:02
    Java五子棋最全教程 首先
  • 摘 要 1 关键词: 1 Abstract 1 Key words: 1 第一章:绪论 2 1.1 前 言 2 第二章 五子棋的相关基础 2 2.1五子棋解释 2 ...4.1程序设计思路 7 4.2程序设计 9 4.3程序的运行结果 17 结 语 18 参考文献 19 致 谢 19
  • Java五子棋Ai-权值法

    千次阅读 2019-03-07 13:01:12
    Java五子棋Ai-权值法一、 什么是权值法?二、实现权值法Ai会面临的问题1、如何表达棋盘上未下处的横竖斜的棋子情况?(类似01120)2、如何将未下处的横竖斜情况和权值联系起来?(Hashmap)3、设置权值的思路是什么?...
  • java基础: 主要刷面经、重点掌握垃圾回收机制 操作系统: 之前没学过,用几天时间看了一下最重要的进程线程、死锁、消费者生产者、哲学家问题、银行家算法 计算机网络:花几天时间复习了一下,重点复习tcp(三次...
  • Java五子棋的简单实现

    2020-10-28 19:38:46
    本次设计是基于知识点Java类和对象以及数组开发的一个小型五子棋游戏程序。游戏开始时,选择黑棋、白棋开局,将一枚棋子落在棋盘一坐标上,然后轮番落子,如此轮流下子,直到某一方首先在棋盘的竖、横或两斜四方向上...
  • 五子棋是一种两人对弈的纯策略型棋类游戏, 是起源于中国古代的传统黑白棋种之一。。。。
  • 简单的无禁手五子棋实现效果图功能运行环境说明源码BoardGame源文件下载地址有疑问看这里 效果图 先来看一下效果图: 功能 悔棋,和棋不做详细说明。 胜场数在效果展示中有相关。 背景可以根据自己的喜好在...
  • Java五子棋的实现(附源码)

    万次阅读 多人点赞 2017-07-22 21:05:23
    思路:**1.首先构建一个Frame框架,来设置菜单选项与按钮点击事件。 MyFrame.java文件代码如下** package StartGame;import javax.swing.ButtonGroup; import javax.swing.Icon; import javax.swing.JButto
  • MySQL备份与恢复(包含数据库备份使用场景,逻辑备份与恢复测试,物理备份与恢复测试以及备份策略的设计思路) 性能优化篇: 影响MySQLServer性能的相关因素(商业需求对性能的影响,系统架构及实现对性能的影响,...
  • java五子棋全代码—可实现悔棋功能

    千次阅读 2021-01-25 22:59:15
    Java编写简单的五子棋——可悔棋! 前言   最近有网友仔细参考了我上一期的五子棋代码,发现了我偷懒没有做悔棋功能,并通过私信的方式找到了我,对我进行了狠狠地批评,说我不讲武德,来欺骗他们这些老同志。嗷...
  • Java实现五子棋效果

    2021-02-20 23:02:11
    Java实现五子棋效果 ...接下来我们就按照这个思路来一步步实现五子棋。 一. 绘制棋盘 由于每一次运行程序系统会自动调用paint函数,我们只需要直接把棋盘的绘制代码写在重写后的paint函数内即可。如下 ...
  • 关于使用java实现控制台版五子棋游戏的代码与想法实现控制台版五子棋游戏思路过程及代码一些遇到的问题以及想法 实现控制台版五子棋游戏 思路过程及代码 编程实现 控制台版 并支持两人对战的五子棋游戏 五子棋这个...
  • java实现AI五子棋

    千次阅读 2018-07-16 22:55:15
    这是学习Java以来自己设计的第一款小游戏,虽然整体设计有点粗糙,电脑智能也比较低...一、五子棋设计要求:  1、设计一个能够实现双人对战及人机对战的五子棋游戏;  2、游戏可实现悔棋及认输等基本操作;  ...
  • 本文是以学校Java面向对象程序设计课程设计要求为背景,利用了Java语言、人工智能算法知识和Eclipse IDE开发平台,开发了五子棋小游戏,本论文论述了五子棋小游戏的概念、结构、基本思路和方法,全文共分为绪论、...
  • JAVA实战3——五子棋游戏设计

    千次阅读 2015-06-09 22:09:58
    一、实践目标:  1.掌握JavaGUI界面设计  2.掌握鼠标事件的监听... 设计一个简单的五子棋程序,能够实现五子棋下棋过程。如下图所示   五子棋运行界面  1.五子棋棋盘类 [java] view plaincopyprint? pa
  • 仿照教材上面围棋软件的设计思路,设计一款五子棋,采用至少5种设计模式 二、引言 五子棋最早源于中国古代尧帝时期,最初流行于少数民族地区,围棋就是从 那时的五子棋渐渐的演变而来的。后来在炎黄子孙的后代流行...
  • Java编写五子棋 题目 :五子棋是全国智力运动会竞技项目之一,是一种两人对弈的纯策略型棋类游戏。通常双方分别使用黑白两色的棋子,下在棋盘直线与横线的交叉点上,先形成五子连珠者获胜。 棋盘效果如下: 任务...
  • 整理一下思路: 1.五子棋的要素:棋盘,棋子,窗体,背景,按钮,面板 2.用到的要点:监听器,哈希表,构造函数,重绘,数组(一维,二维),接口类,流式布局 3.基本功能实现 先要有个界面才能开始游戏-&gt...
  • Java五子棋程序

    千次阅读 多人点赞 2014-01-02 14:30:50
    一、实验题目  五子棋游戏。 二、问题分析  五子棋是双人博弈棋类益智游戏,由围棋演变而来,属纯策略型。棋盘通常15*15,即15行,15列,共225个交叉点,即棋子落点;... 本次Java编程我的目的是现实人机对战,即游
  • Java版单机五子棋游戏源代码,课程设计专用。界面思路,算法,txt文件说明
  • 五子棋游戏Java代码简单实现(含活动图和类图设计) @TOPIC 游戏活动图 类图 代码实现 import java.lang.Math; import java.io.*; import java.util.Scanner; class Gobang { // 定义棋盘和棋盘大小 private ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 825
精华内容 330
关键字:

java五子棋设计思路

java 订阅