java之五子棋解析

最新推荐文章于 2022-12-04 18:46:08 发布
最新推荐文章于 2022-12-04 18:46:08 发布
阅读量251 收藏 3
点赞数 1
文章标签： java
原文链接：https://my.oschina.net/u/3400640/blog/881214
版权

这里是来自网上的源码 ，当然，有许多直接粘贴然后发博客，那里setBackground(Color.blue)明明是蓝色，后面却说把背景设置成橘黄色，这里我也不多说了。 

下面是我仔细看过源码之后，加了许多注释，相信大部人都能看懂。

还有，我也希望各位博友也给出不同的见解。我们也可以试着做一个人机对战的功能出来！^_^

package a1;
 

import java.awt.Color;  
import java.awt.Cursor;  
import java.awt.Dimension;  
import java.awt.Graphics;  
import java.awt.Graphics2D;  
import java.awt.Image;  
import java.awt.RadialGradientPaint;  
import java.awt.RenderingHints;  
import java.awt.Toolkit;  
import java.awt.event.MouseEvent;  
import java.awt.event.MouseListener;  
import java.awt.event.MouseMotionListener;  
import java.awt.geom.Ellipse2D;  
  
import javax.swing.*;  
/** 
 * 五子棋--棋盘类  
 */  
  
public class ChessBoard extends JPanel implements MouseListener {  
   /**
	 * 
	 */
	private static final long serialVersionUID = 1L;
   public static final int MARGIN=30;//边距  
   public static final int GRID_SPAN=35;//网格间距  
   public static final int ROWS=15;//棋盘行数  
   public static final int COLS=15;//棋盘列数  
     
   Point[] chessList=new Point[(ROWS+1)*(COLS+1)];//初始每个数组元素为null，即定义这个数组为棋子的数目
   boolean isBlack=true;//默认开始是黑棋先  
   boolean gameOver=false;//游戏是否结束  
   int chessCount;//当前棋盘棋子的个数  
   int xIndex,yIndex;//当前刚下棋子的索引  
     
   Image img;  
   Image shadows;  
   Color colortemp;  
   public ChessBoard(){  
        
       setBackground(Color.lightGray);//设置背景颜色 
       img=Toolkit.getDefaultToolkit().getImage("board.jpg");  
       shadows=Toolkit.getDefaultToolkit().getImage("shadows.jpg");
       //以上的语句只有在加入board.jpg资源后才能有实际意义
       addMouseListener(this);  
       addMouseMotionListener(new MouseMotionListener(){  
           public void mouseDragged(MouseEvent e){  
                 
           }  
             
           public void mouseMoved(MouseEvent e){  
             int x1=(e.getX()-MARGIN+GRID_SPAN/2)/GRID_SPAN;  
             //将鼠标点击的坐标位置转成网格索引  
             int y1=(e.getY()-MARGIN+GRID_SPAN/2)/GRID_SPAN;
             //以上语句将窗口的坐标转换成棋盘中的索引，比如1格，2格
             
             /*但是此处我无法理解的是为何要加上1/2的网格间距，等各位大神赐教*/
             
             
             //游戏已经结束不能下  
             //落在棋盘外不能下  
             //x，y位置已经有棋子存在，不能下  
             if(x1<0||x1>ROWS||y1<0||y1>COLS||gameOver||findChess(x1,y1))  
                 setCursor(new Cursor(Cursor.DEFAULT_CURSOR));  
             //设置成默认状态  
             else setCursor(new Cursor(Cursor.HAND_CURSOR));  
               
           }  
       });  
   }   
     
    
  
//绘制  
   public void paintComponent(Graphics g){  
       
       super.paintComponent(g);//画棋盘  
       
       /*int imgWidth= img.getWidth(this);  
       int imgHeight=img.getHeight(this);//获得图片的宽度与高度  
       int FWidth=getWidth();  
       int FHeight=getHeight();//获得窗口的宽度与高度  
       int x=(FWidth-imgWidth)/2;  
       int y=(FHeight-imgHeight)/2;  
       g.drawImage(img, x, y, null);  */
       //这段在没有资源的情况，也就是没有将board.jpg加到src的情况下是无作用的，
      
         
       for(int i=0;i<=ROWS;i++){//画横线  
           g.drawLine(MARGIN, MARGIN+i*GRID_SPAN, MARGIN+COLS*GRID_SPAN, MARGIN+i*GRID_SPAN);  
       }  
       for(int i=0;i<=COLS;i++){//画竖线  
           g.drawLine(MARGIN+i*GRID_SPAN, MARGIN, MARGIN+i*GRID_SPAN, MARGIN+ROWS*GRID_SPAN);  
             
       }  
         
       //画棋子  
       for(int i=0;i<chessCount;i++){  
           //网格交叉点x，y坐标  
           int xPos=chessList[i].getX()*GRID_SPAN+MARGIN;  
           int yPos=chessList[i].getY()*GRID_SPAN+MARGIN;  
           g.setColor(chessList[i].getColor());//设置颜色  
           //g.fillOval(xPos-Point.DIAMETER/2, yPos-Point.DIAMETER/2,  
                           //Point.DIAMETER, Point.DIAMETER);  
           //g.drawImage(shadows, xPos-Point.DIAMETER/2, yPos-Point.DIAMETER/2, Point.DIAMETER, Point.DIAMETER, null);  
           colortemp=chessList[i].getColor();  
           if(colortemp==Color.black){  
               RadialGradientPaint paint = new RadialGradientPaint(xPos-Point.DIAMETER/2+25, yPos-Point.DIAMETER/2+10, 20, new float[]{0f, 1f}  
               , new Color[]{Color.WHITE, Color.BLACK});  
               ((Graphics2D) g).setPaint(paint); 
               //用上面语句实现棋子的颜色更有立体感，而不是一味的黑色和白色
               ((Graphics2D) g).setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);  
               ((Graphics2D) g).setRenderingHint(RenderingHints.KEY_ALPHA_INTERPOLATION, RenderingHints.VALUE_ALPHA_INTERPOLATION_DEFAULT);  
               //这里是实现图形抗锯齿，使图形更圆润
           }  
           else if(colortemp==Color.white){  
               RadialGradientPaint paint = new RadialGradientPaint(xPos-Point.DIAMETER/2+25, yPos-Point.DIAMETER/2+10, 70, new float[]{0f, 1f}  
               , new Color[]{Color.WHITE, Color.BLACK});  
               ((Graphics2D) g).setPaint(paint);  
               ((Graphics2D) g).setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);  
               ((Graphics2D) g).setRenderingHint(RenderingHints.KEY_ALPHA_INTERPOLATION, RenderingHints.VALUE_ALPHA_INTERPOLATION_DEFAULT);  
  
           }  
           
           Ellipse2D e = new Ellipse2D.Float(xPos-Point.DIAMETER/2, yPos-Point.DIAMETER/2, 34, 35);  
           ((Graphics2D) g).fill(e);  
           //标记最后一个棋子的红矩形框  
             
           if(i==chessCount-1){//如果是最后一个棋子  
               g.setColor(Color.red);  
               g.drawRect(xPos-Point.DIAMETER/2, yPos-Point.DIAMETER/2,  
                           34, 35);  
           }  
       }  
   }  
     
   public void mousePressed(MouseEvent e){//鼠标在组件上按下时调用  
         
       //游戏结束时，不再能下  
       if(gameOver) return;  
         
       String colorName=isBlack?"黑棋":"白棋";  
         
       //将鼠标点击的坐标位置转换成网格索引  
       xIndex=(e.getX()-MARGIN+GRID_SPAN/2)/GRID_SPAN;  
       yIndex=(e.getY()-MARGIN+GRID_SPAN/2)/GRID_SPAN;  
         
       //落在棋盘外不能下  
       if(xIndex<0||xIndex>ROWS||yIndex<0||yIndex>COLS)  
           return;  
         
       //如果x，y位置已经有棋子存在，不能下  
       if(findChess(xIndex,yIndex))return;  
         
       //可以进行时的处理  
       Point ch=new Point(xIndex,yIndex,isBlack?Color.black:Color.white);  
       chessList[chessCount++]=ch;  
        repaint();//通知系统重新绘制  
        
         
       //如果胜出则给出提示信息，不能继续下棋  
         
       if(isWin()){  
           String msg=String.format("恭喜，%s赢了！", colorName);  
           JOptionPane.showMessageDialog(this, msg);  
           gameOver=true;  
       }  
       isBlack=!isBlack;  
     }  
   //覆盖mouseListener的方法  
   public void mouseClicked(MouseEvent e){  
       //鼠标按键在组件上单击时调用  
   }  
   public void mouseEntered(MouseEvent e){  
       //鼠标进入到组件上时调用  
   }  
   public void mouseExited(MouseEvent e){  
       //鼠标离开组件时调用  
   }  
   public void mouseReleased(MouseEvent e){  
       //鼠标按钮在组件上释放时调用  
   }  
   //在棋子数组中查找是否有索引为x，y的棋子存在  
   private boolean findChess(int x,int y){  
       for(Point c:chessList){  
           if(c!=null&&c.getX()==x&&c.getY()==y)  
               return true;  
       }  
       return false;  
   }  
     
     
   private boolean isWin(){  
       int continueCount=1;//连续棋子的个数  
        
       //横向向西寻找  
       for(int x=xIndex-1;x>=0;x--){  
           Color c=isBlack?Color.black:Color.white;  
           if(getChess(x,yIndex,c)!=null){  
               continueCount++;  
           }else  
               break;  
       }  
      //横向向东寻找  
       for(int x=xIndex+1;x<=COLS;x++){  
          Color c=isBlack?Color.black:Color.white;  
          if(getChess(x,yIndex,c)!=null){  
             continueCount++;  
          }else  
             break;  
       }  
       if(continueCount>=5){  
             return true;  
       }else   
       continueCount=1;  
         
       //继续另一种搜索纵向  
       //向上搜索  
       for(int y=yIndex-1;y>=0;y--){  
           Color c=isBlack?Color.black:Color.white;  
           if(getChess(xIndex,y,c)!=null){  
               continueCount++;  
           }else  
               break;  
       }  
       //纵向向下寻找  
       for(int y=yIndex+1;y<=ROWS;y++){  
           Color c=isBlack?Color.black:Color.white;  
           if(getChess(xIndex,y,c)!=null)  
               continueCount++;  
           else  
              break;  
         
       }  
       if(continueCount>=5)  
           return true;  
       else  
           continueCount=1;  
         
         
       //继续另一种情况的搜索：斜向  
       //东北寻找  
       for(int x=xIndex+1,y=yIndex-1;y>=0&&x<=COLS;x++,y--){  
           Color c=isBlack?Color.black:Color.white;  
           if(getChess(x,y,c)!=null){  
               continueCount++;  
           }  
           else break;  
       }  
       //西南寻找  
       for(int x=xIndex-1,y=yIndex+1;x>=0&&y<=ROWS;x--,y++){  
           Color c=isBlack?Color.black:Color.white;  
           if(getChess(x,y,c)!=null){  
               continueCount++;  
           }  
           else break;  
       }  
       if(continueCount>=5)  
           return true;  
       else continueCount=1;  
         
         
       //继续另一种情况的搜索：斜向  
       //西北寻找  
       for(int x=xIndex-1,y=yIndex-1;x>=0&&y>=0;x--,y--){  
           Color c=isBlack?Color.black:Color.white;  
           if(getChess(x,y,c)!=null)  
               continueCount++;  
           else break;  
       }  
       //东南寻找  
       for(int x=xIndex+1,y=yIndex+1;x<=COLS&&y<=ROWS;x++,y++){  
           Color c=isBlack?Color.black:Color.white;  
           if(getChess(x,y,c)!=null)  
               continueCount++;  
           else break;  
       }  
       if(continueCount>=5)//判断是否具备五子相连
           return true;  
       else continueCount=1;  
         
       return false;  
     }  
     
     
   private Point getChess(int xIndex,int yIndex,Color color){  
       for(Point p:chessList){  
           if(p!=null&&p.getX()==xIndex&&p.getY()==yIndex  
                   &&p.getColor()==color)  
               return p;  
       }  
       return null;  
   }  
     
     
   public void restartGame(){  
       //清除棋子  
       for(int i=0;i<chessList.length;i++){  
           chessList[i]=null;  
       }  
       //恢复游戏相关的变量值  
       isBlack=true;  
       gameOver=false; //游戏是否结束  
       chessCount =0; //当前棋盘棋子个数  
       repaint();  
   }  
     
   //悔棋  
   public void goback(){  
       if(chessCount==0)  
           return ;  
       chessList[chessCount-1]=null;  
       chessCount--;  
       if(chessCount>0){  
           xIndex=chessList[chessCount-1].getX();  
           yIndex=chessList[chessCount-1].getY();  
       }  
       isBlack=!isBlack;  
       repaint();  
   }  
     
   //矩形Dimension，让窗口一出现就保持一个比棋盘两边各大30像素
  
   public Dimension getPreferredSize(){  
       return new Dimension(MARGIN*2+GRID_SPAN*COLS,MARGIN*2  
                            +GRID_SPAN*ROWS);  
   }
}

这里是棋子类 

package a1;

import java.awt.Color;  
/** 
 * 棋子类 
 */  
public class Point {  
  private int x;//棋盘中的x索引  
  private int y;//棋盘中的y索引  
  private Color color;//颜色  
  public static final int DIAMETER=30;//直径  
    
  public Point(int x,int y,Color color){  
      this.x=x;  
      this.y=y;  
      this.color=color;  
  }   
    
  public int getX(){//拿到棋盘中x的索引  
      return x;  
  }  
  public int getY(){  
      return y;  
  }  
  public Color getColor(){//获得棋子的颜色  
      return color;  
  }  
}

下面是框架类

 import java.awt.event.*;  
import java.awt.*;  
  
import javax.swing.*;  
/* 
 五子棋主框架
 */  
public class StartChessJFrame extends JFrame {  
  /**
     * 
     */
  private static final long serialVersionUID = 1L;
  private ChessBoard chessBoard;  
  private JPanel toolbar;  
  private JButton startButton,backButton,exitButton;  
    
  private JMenuBar menuBar;  
  private JMenu sysMenu;  
  private JMenuItem startMenuItem,exitMenuItem,backMenuItem;  
  //重新开始，退出，和悔棋菜单项  
  public StartChessJFrame(){  
      setTitle("单机版五子棋");//设置标题  
      chessBoard=new ChessBoard();  
      
        
      Container contentPane=getContentPane();  
      contentPane.add(chessBoard);  
      chessBoard.setOpaque(true);  
        
        
      //创建和添加菜单  
      menuBar =new JMenuBar();//初始化菜单栏  
      sysMenu=new JMenu("系统");//初始化菜单  
      //初始化菜单项  
      startMenuItem=new JMenuItem("重新开始");  
      exitMenuItem =new JMenuItem("退出");  
      backMenuItem =new JMenuItem("悔棋");  
      //将三个菜单项添加到菜单上  
      sysMenu.add(startMenuItem);  
      sysMenu.add(exitMenuItem);  
      sysMenu.add(backMenuItem);
      //初始化按钮事件监听器内部类  
      MyItemListener lis=new MyItemListener();  
      //将三个菜单注册到事件监听器上  
      this.startMenuItem.addActionListener(lis);  
      backMenuItem.addActionListener(lis);  
      exitMenuItem.addActionListener(lis);  
      menuBar.add(sysMenu);//将系统菜单添加到菜单栏上  
      setJMenuBar(menuBar);//将menuBar设置为菜单栏  
        
      toolbar=new JPanel();//工具面板实例化  
      //三个按钮初始化  
      startButton=new JButton("重新开始");  
      exitButton=new JButton("退出");  
      backButton=new JButton("悔棋");  
      //将工具面板按钮用FlowLayout布局  
      toolbar.setLayout(new FlowLayout(FlowLayout.LEFT));  
      //将三个按钮添加到工具面板  
      toolbar.add(startButton);  
      toolbar.add(exitButton);  
      toolbar.add(backButton);  
      //将三个按钮注册监听事件  
      startButton.addActionListener(lis);  
      exitButton.addActionListener(lis);  
      backButton.addActionListener(lis);  
      //将工具面板布局到界面”南方“也就是下方  
      add(toolbar,BorderLayout.SOUTH);  
      add(chessBoard);//将面板对象添加到窗体上  
      //设置界面关闭事件  
      setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);  
      //setSize(800,800);  
      pack();//自适应大小  
        
  }  
    
  private class MyItemListener implements ActionListener{  
      public void actionPerformed(ActionEvent e){  
          Object obj=e.getSource();//获得事件源  
          if(obj==StartChessJFrame.this.startMenuItem||obj==startButton){  
              //重新开始  
              //JFiveFrame.this内部类引用外部类  
              System.out.println("重新开始");  
              chessBoard.restartGame();  
          }  
          else if (obj==exitMenuItem||obj==exitButton)  
              System.exit(0);  
          else if (obj==backMenuItem||obj==backButton){  
              System.out.println("悔棋...");  
              chessBoard.goback();  
          }  
      }  
  }  
    
    
    
  public static void main(String[] args){  
      StartChessJFrame f=new StartChessJFrame();//创建主框架  
      f.setVisible(true);//显示主框架  
        
  }  
}

 

转载于:https://my.oschina.net/u/3400640/blog/881214

chenjialan9214
关注
  • 1
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
五子棋智能算法解析(VC .net)
张远山的专栏
06-12 3537
           大二的时候一次小学期作业写的五子棋智能算法。这里分析一下算法实现。数据结构分析：我们把整个棋盘看成一个二维数组，为了便于扩展，棋盘大小最大是25×25，可以自由选择棋盘大小。在棋盘的数组上，用数值的大小表示棋盘的危急程度，当然对于下棋双方来说，相对一边越而对另一边就越有利。一个位置用一个结构来表示：struct Seat{       int x;//
五子棋代码解析
捕风汉子
11-12 1933
 近来随着计算机的快速发展，各种棋类游戏被纷纷请进了电脑，使得那些喜爱下棋，又常常苦于没有对手的棋迷们能随时过足棋瘾。而且这类软件个个水平颇高，大有与人脑分庭抗礼之势。其中战胜过国际象棋世界冠军-卡斯帕罗夫的“深蓝”便是最具说服力的代表；其它像围棋的“手淡”、象棋的“将族”等也以其优秀的人工智能深受棋迷喜爱；而我们今天将向大家介绍的是五子棋的算法。 当我们与电脑对战时，您知道这些软件是怎样
java-简单的五子棋（说明文档）
簡然
01-14 542
gitee源码链接 目录概述程序概要设计文件结构程序主流程图程序结构（略写）1. class ChessPinal2. class 水波背景3. class 棋盘4. class Chess5. class 计时器6.class 数据程序详细设计模块1 游戏主界面模块1.1 ChessPinal模块1.2 计时器功能模块2 动态水波背景模块2.1 水波背景模块2.2 波纹扩散算法模块2.3 背景的paintComponent模块3 棋盘界面模块3.1 棋盘的paintComponent模块
小游戏——五子棋（Java）
Tough_dxx的博客
02-20 559
首先介绍一下五子棋的规则： 1、参与人数为两个人； 2、一个人代表黑方，一个人代表白方； 3、先在棋盘上不管是水平、竖直、左斜、右斜的这四个方向上出现连续的五个颜色相同的棋子，表示该方获胜。 接下来再介绍在控制台是如何打印一个五子棋—— 1、规定棋盘的大小为：10*10，并且用0来表示初始化的棋盘； 2、用1表示黑方，用2表示白方； 具体的代码实现如下： import jav...
五子棋设计思想（java）
07-02
五子棋是一种两人对弈的纯策略型棋类游戏， 是起源于中国古代的传统黑白棋种之一。。。。
java游戏之五子棋解析
blue_sky_wait_me
04-17 1011
这里是来自网上的源码 ，当然，有许多直接粘贴然后发博客，那里setBackground(Color.blue)明明是蓝色，后面却说把背景设置成橘黄色，这里我也不多说了。  下面是我仔细看过源码之后，加了许多注释，相信大部人都能看懂。 还有，我也希望各位博友也给出不同的见解。我们也可以试着做一个人机对战的功能出来！^_^ import java.awt.Color; import java
java--五子棋程序
**伟（JAVA）(Java)
01-09 829
我这里有五子棋的java程序，有源文件，也有弄好的，有谁要的，来吧就！！ 我有时间给你传过去，还有一些别的小程序，贪吃蛇什么的 先复一部分吧，也不是很多！ 看看吧，一共是800多行，呵呵其中，代码可能有缺失，望大家在测试代码的时候，添加一下自己的思绪，自己整理，那样代码就属于你的了--哈哈import java.util.*; import java.io.*; i
java编写简易五子棋，分析设计到完成《Blind-Stab》
qq_41054844的博客
08-05 535
五子棋 今天我们就用java写一个简单的五子棋代码！ 分析： 1,我们想写一个五子棋，首先我们得有棋盘吧，我们不可能真正的造出棋盘，那我们就模拟棋盘的样子。用String[][]数组模拟 2，有了棋盘接下来我们就要完善这个棋盘，因为这个棋盘还只是一个空壳子，并且这个棋盘是整个游戏过程中都得使用的，我们就定义成 public static String [ ] [ ] 类型。有了棋盘的壳子，...
Java单机版五子棋
Software's Blog
01-10 2358
这几天做了一个小应用，单机版的五子棋开发。分享一下源代码。总共有三个类文件，分别为：StartChessJFrame.java, Point.java, ChessBoard.java//StartChessJFrame.java import javax.swing.*; import java.awt.event.*; import java.awt.*; /** * This is main
基于JAVA实现的网络五子棋游戏
demongwc的博客
07-24 265
一、实验目的 熟练掌握基本网络编程技术 掌握Swing图形用户界面编程 掌握多线程编程的基本原理，能使用多线程设计服务器端程序 培养独立查找资料，并解决问题的能力 点击此处下载文档和源码 ...
五子棋JavaSwing开发
06-10
客户端，数据库模式开发，适用于初学者，了解数据库，Java之间的连接。
java五子棋的实现（1）
fengqiniuhebahuang的博客
11-01 252
基本界面的实现 创建主窗体，为其添加五子棋基本功能的按钮：开始游戏，悔棋，认输，对战方式，并绘制棋盘，因为棋盘和棋子的参数是恒定的，我们定义一个接口 public interface GoBangInformation { public static final int X=50,Y=100,SIZE=35,CHESS_SIZE=33,ROW=15,COLUMN=15; } 然后让整个...
Java练手项目实战——五子棋游戏实现思路及源码
weixin_46822367的博客
12-14 1万+
目录一、实现功能二、实现思路1、窗体设计2、棋盘设计3、棋子坐标存储设计4、游戏状态设计5、开始游戏与重新开始游戏的实现6、悔棋的实现7、认输的实现8、游戏结束的判断，即是否有同色五连棋子。9、双缓冲技术防止屏幕闪烁三、实现代码1、主函数2、窗体及实现类四、项目素材1、棋盘2、菜单背景图3、黑白棋子4、游戏小图标 一、实现功能 1、有良好的UI界面，用户体验良好 2、鼠标点击进行出棋子，玩家两人轮流下棋 3、能够判断是否五子相连及输赢 4、玩家能够重新开始游戏 5、可以悔棋，要经过对方同意 6、轮到玩家的
超萌新级的Java项目实践——五子棋（二）
萌新の程序员之路
10-01 536
这部分内容需要一定的数组之类的数据结构的基础，这一部分讲解一下五子棋的重绘和防止重复在一个位置下棋的思路和解决方案。 之前是实现了简易的界面的点一下绘制一个棋子以及棋子的换边。但是，我们在下棋的函数里没有任何的判断语句是用于判断点击的位置是否有棋子，所以导致可以在一个位置不断下棋。 于是，我们需要一个用于存储位置的二维数组（当然也可以使用一维数组，本文介绍二维数组的使用方法），本人命名为pie...
JAVA之五子棋判断输赢功能实现
weixin_66942853的博客
05-24 2195
五子棋的规则很简单，即横或竖或四个斜方向有连续五个颜色一样的棋子，就获胜。所以由此可以得到五子棋判断输赢基本的原理：运用计数器，每下一步，若有横/竖/四个斜方向连续的棋子，则计数器+1，判断计数器是否大于等于5，若大于等于5，则判断获胜
20135337朱荟潼——实验三
weixin_34110749的博客
06-03 147
实验三 敏捷开发与XP实践 实验内容 1. XP基础 2. XP核心实践 3. 相关工具 实验步骤 （一）敏捷开发与XP 软件工程是把系统的、有序的、可量化的方法应用到软件的开发、运营和维护上的过程。软件工程包括下列领域：软件需求分析、软件设计、软件构建、软件测试和软件维护。 人们在开发、运营、维护软件的过程中有很多技术、做法、习惯和思想体系。软件工程把这些相关的技术和过程统一到一个...
Java实现五子棋小游戏(附思路讲解,全部代码,游戏截图)
最新发布
qq_55383558的博客
12-04 1万+
Java实现五子棋小游戏(附思路讲解,全部代码,游戏截图)
java 辐射渐变_Java：绘制渐变的饼图: LinearGradientPaint, RadialGradientPaint
weixin_30824121的博客
02-25 516
import java.awt.Color;import java.awt.geom.Arc2D;import java.awt.geom.Area;import java.awt.geom.GeneralPath;import java.awt.geom.Point2D;class Pie3D {privateArc2Darc;// 这里的弧并不是圆上的一弧，而是椭圆的一部分.private A...
Java实践（十一）——五子棋
热门推荐
涛涌四海向大家学习，与大家携手共进……
11-12 12万+
一、实践目标：       1.掌握JavaGUI界面设计       2.掌握鼠标事件的监听（MouseListener，MouseMotionListener）二、实践内容：      设计一个简单的五子棋程序，能够实现五子棋下棋过程。如下图所示 五子棋运行界面      1.五子棋棋盘类package cn.edu.ouc.fiveChess; import java.awt.Color;
Java控制台五子棋实现解析
在《疯狂Java实战演义》中，作者杨恩雄通过编写控制台五子棋游戏，引导读者逐步掌握Java编程的基础知识。控制台五子棋虽然没有华丽的图形界面，但其核心在于游戏逻辑和数据处理，这正是编程学习的重点。了解并实现...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值