软件工程——个人项目：五子棋

实验报告

一丶设计摘要：

通过本次五子棋的设计，实现对本学期内容的回顾与综合运用，包括类的建立，用类创建对象，方法的调用，图形组件的使用方法，图形界面的布局形式，事件处理机制，文件操作的基本方法，数据读写的基本用法、鼠标事件等。

Java既是一种程序设计语言，也是一个完整的平台。作为一种程序语言，它简洁、面向对象、安全、健壮，以及适用于Internet技术；而作为一个平台（JRE，Java Runtime Environment，Java运行环境或者说是Java虚拟机），对于符合Sun公司Java标准的应用程序，都可以在Java平台上正确运行，与程序运行的操作系统无关。 这个五子棋游戏正是用这个平台做的，在实践中充分体现出了Java面向对象给我们带来的方便。

二丶功能需求：

本次课程设计实现了五子棋程序的基本玩法，可以扫描棋盘记录连在一起的黑白棋子数，从而判断黑白棋子的胜负。

三丶源代码：

 
 
1.AutoPlay：public class AutoPlay{

int x,y;
              void autoPlay(int chesspad[][],int a,int b){
              int randomNumber=(int)(Math.random()*8)+1;
            switch(randomNumber){
               case(1):
                    if(chesspad[a-1][b-1]==0)
                    {x=a-1;y=b-1;}
                    else if(chesspad[a-2][b-2]==0)
                    {x=a-2;y=b-2;}
                    else {x=a-3;y=b-3;}  
                    break;
                    
               case(2):
                    if(chesspad[a-1][b]==0)
                    {x=a-1;y=b;}
                    else if(chesspad[a-2][b]==0)
                    {x=a-2;y=b;}
                    else {x=a-3;y=b;}
                    break;
       case(3):
                    if(chesspad[a-1][b+1]==0)
                    {x=a-1;y=b+1;}
                    else if(chesspad[a-2][b+2]==0)
                    {x=a-2;y=b+2;}
                    else {x=a-3;y=b+3;}
                    break;
               case(4):
                    if(chesspad[a][b+1]==0)
                    {x=a;y=b+1;}
                    else if(chesspad[a][b+2]==0)
                    {x=a;y=b+2;}
                    else {x=a;y=b+3;}
                    break;
               case(5):
                     if(chesspad[a+1][b+1]==0)
                     {x=a+1;y=b+1;}
                     else if(chesspad[a+2][b+2]==0)
                     {x=a+2;y=b+2;}
                     else {x=a+3;y=b+3;}
                     break;
               case(6):
                     if(chesspad[a+1][b]==0)
                     {x=a+1;y=b;}
                     else  if(chesspad[a+2][b]==0)
                     {x=a+2;y=b;}
                     else {x=a+3;y=b;}
                     break;
               case(7):
                      if(chesspad[a+1][b-1]==0)
                      {x=a+1;y=b-1;}
                      else if(chesspad[a+2][b-2]==0)
                      {x=a+2;y=b-2;}
                      else {x=a+3;y=b-3;}
                      break;
               case(8):
                       if(chesspad[a][b-1]==0)
                       {x=a;y=b-1;}
                       else if(chesspad[a][b-2]==0)
                       {x=a;y=b-2;}
                       else{x=a;y=b+3;}
                       break;
              }
        }
 
}

2.Chess：
  import java.awt.*;
  import java.awt.event.*;
  class ChessPad extends Panel implements MouseListener,ActionListener{
     int array[][]=new int[19][19];
     Scan scanp=new Scan();
     Scan scanc=new Scan(); 
     AutoPlay autoPlay=new AutoPlay();
     Evaluate evaluatep=new Evaluate();
     Evaluate evaluatec=new Evaluate();
     Sort sort=new Sort();
     int i=0;
     int x=-1,y=-1,棋子颜色=1;
     Button button=new Button("重新开局");
     TextField text_1=new TextField("请黑棋下子"),
               text_2=new TextField(),
               text_3=new TextField();
     ChessPad(){
         setSize(440,440);
         setLayout(null);setBackground(Color.pink);
         addMouseListener(this);add(button);button.setBounds(10,5,60,26);
         button.addActionListener(this);
         add(text_1);  text_1.setBounds(90,5,90,24);
         add(text_2);  text_2.setBounds(290,5,90,24);
         add(text_3);  text_3.setBounds(200,5,80,24);
         for(int i=0;i<19;i++)
          for(int j=0;j<19;j++)
              {array[i][j]=0;}
         for(int i=0;i<19;i++)
          for(int j=0;j<19;j++)
           for(int h=0;h<5;h++)
              {scanp.shape[i][j][h]=0;
              scanc.shape[i][j][h]=0;} 
         text_1.setEditable(false);
         text_2.setEditable(false);
        
         }
      public void paint(Graphics g){
          for (int i=40;i<=400;i=i+20){
               g.drawLine(40,i,400,i);
               }
         
          for(int j=40;j<=400;j=j+20){
              g.drawLine(j,40,j,400);
              }
       
          g.fillOval(97,97,6,6);
          g.fillOval(337,97,6,6);
          g.fillOval(97,337,6,6);
          g.fillOval(337,337,6,6);
          g.fillOval(217,217,6,6);
          }
      public void mousePressed(MouseEvent e){
         int a=0,b=0;
         if(e.getModifiers()==InputEvent.BUTTON1_MASK){
               x=(int)e.getX();y=(int)e.getY();
               ChessPoint_black chesspoint_black=new ChessPoint_black(this);
               ChessPoint_white chesspoint_white=new ChessPoint_white(this);
               i++;
               text_3.setText("这是第"+i+"步");
   
          
           if((x+5)/20<2||(y+5)/20<2||(x-5)/20>19||(y-5)/20>19)
                 {}
               else { a=(x+10)/20;b=(y+10)/20;
                      if(array[b-2][a-2]==0&&棋子颜色==1){
                         this.add(chesspoint_black);
                         chesspoint_black.setBounds(a*20-9,b*20-9,18,18);
                         棋子颜色=棋子颜色*(-1);
                         array[b-2][a-2]=1;
                         if (Judge.judge(array,1)){
                             text_1.setText("黑棋赢!");棋子颜色=2;removeMouseListener(this);}
                         else{
                             
                           
                              text_1.setText("");  }
                         }
                     }
                
                  
                 
                 
                     if(i>2&&棋子颜色==-1){
                         scanp.scan(array,1);
                         scanc.scan(array,-1);
                         sort.sort(scanp.shape);
                         sort.sort(scanc.shape);
                         evaluatep.evaluate(scanp.shape);
                         evaluatec.evaluate(scanc.shape);
                       
                         棋子颜色=棋子颜色*(-1);
                         this.add(chesspoint_white);
                         if(evaluatep.max>evaluatec.max){
                         text_2.setText(evaluatep.max_x+" "+evaluatep.max_y+" "+evaluatep.max);
                         chesspoint_white.setBounds((evaluatep.max_y+2)*20-9,(evaluatep.max_x+2)*20-9,18,18);
                         array[evaluatep.max_x][evaluatep.max_y]=-1;
                         text_1.setText("请黑棋下子");
                         for(int i=0;i<19;i++)
                           for(int j=0;j<19;j++)
                             for(int h=0;h<5;h++)
                               {scanp.shape[i][j][h]=0;
                                scanc.shape[i][j][h]=0;}
                         }
                         else
                        
                         {
                         text_2.setText(evaluatec.max_x+" "+evaluatec.max_y+" "+evaluatec.max);
                         chesspoint_white.setBounds((evaluatec.max_y+2)*20-9,(evaluatec.max_x+2)*20-9,18,18);
                        
                         array[evaluatec.max_x][evaluatec.max_y]=-1;
                         if (Judge.judge(array,-1))
                         {
                            text_2.setText("白棋赢!");棋子颜色=2;removeMouseListener(this);}
                         else{
                          
                            text_1.setText("请黑棋下子");
                         for(int i=0;i<19;i++)
                           for(int j=0;j<19;j++)
                             for(int h=0;h<5;h++)
                               {scanp.shape[i][j][h]=0;
                                scanc.shape[i][j][h]=0;}
                             }
                         }
                     }
                    
                     if(i<=2&&棋子颜色==-1)                         
                        {
                         autoPlay.autoPlay(array,b-2,a-2);
                         this.add(chesspoint_white);
                         棋子颜色=棋子颜色*(-1);
                         chesspoint_white.setBounds((autoPlay.y+2)*20-9,(autoPlay.x+2)*20-9,18,18);
                         array[autoPlay.x][autoPlay.y]=-1;
                         if (Judge.judge(array,-1))
                         {
                            text_2.setText("白棋赢!");棋子颜色=2;removeMouseListener(this);}
                         else{
                          
                            text_1.setText("请黑棋下子");
                            text_2.setText(autoPlay.x+" "+autoPlay.y); } 
                     } 
                                    
                     }
         }
   
  public void mouseReleased(MouseEvent e){}
  public void mouseEntered(MouseEvent e){}
  public void mouseExited(MouseEvent e){}
  public void mouseClicked(MouseEvent e){}            
  public void actionPerformed(ActionEvent e)
      {this.removeAll();
       棋子颜色=1;
       add(button);button.setBounds(10,5,60,26);
       add(text_1);text_1.setBounds(90,5,90,24);
       text_2.setText("");
       text_1.setText("请黑棋下子");
       add(text_2);
       text_2.setBounds(290,5,90,24);
       add(text_3);  text_3.setBounds(200,5,80,24);
       i=0;
       text_3.setText("这是第"+i+"步");
       for(int i=0;i<19;i++)
       for(int j=0;j<19;j++)
       {array[i][j]=0;}
       for(int i=0;i<19;i++)
         for(int j=0;j<19;j++)
           for(int h=0;h<5;h++)
              {scanp.shape[i][j][h]=0;
              scanc.shape[i][j][h]=0;}    
       addMouseListener(this);
       }
  }
  class ChessPoint_black extends Canvas implements MouseListener{
       ChessPad chesspad=null;
       ChessPoint_black(ChessPad p){
           setSize(20,20);
           addMouseListener(this);
           chesspad=p;
           }
       public void paint(Graphics g){
            g.setColor(Color.black);g.fillOval(0,0,18,18);
            }
       public void mousePressed(MouseEvent e){
            /*if(e.getModifiers()==InputEvent.BUTTON3_MASK){
                 chesspad.remove(this);
                 chesspad.棋子颜色=1;
                 chesspad.text_2.setText("");  
                 chesspad.text_1.setText("请黑棋下子");
                 }*/
            }
        public void mouseReleased(MouseEvent e){}   
        public void mouseEntered(MouseEvent e){}   
        public void mouseExited(MouseEvent e){}   
        public void mouseClicked(MouseEvent e){
     
            }   
        }
  class ChessPoint_white extends Canvas implements MouseListener{
        ChessPad chesspad=null;
        ChessPoint_white(ChessPad p){
           setSize(20,20);addMouseListener(this);
           chesspad=p;
           }
       public void paint(Graphics g){
            g.setColor(Color.white);g.fillOval(0,0,18,18);
            }
       public void mousePressed(MouseEvent e){
            /*if(e.getModifiers()==InputEvent.BUTTON3_MASK){
                 chesspad.remove(this);
                 chesspad.棋子颜色=-1;
                 chesspad.text_2.setText("请白棋下子");
                 chesspad.text_1.setText("");
                 }*/
            }
        public void mouseReleased(MouseEvent e){}   
        public void mouseEntered(MouseEvent e){}   
        public void mouseExited(MouseEvent e){}   
        public void mouseClicked(MouseEvent e){
         
            }   
        }
  public class Chess extends Frame{
    
      ChessPad chesspad=new ChessPad();
   
   
      Chess(){
          setVisible(true);
          setLayout(null);
          Label label=new Label("五子棋",Label.CENTER);
          add(label);label.setBounds(70,55,440,26);
          label.setBackground(Color.orange);
          add(chesspad);chesspad.setBounds(70,90,440,440);
          addWindowListener(new WindowAdapter()
                {public void windowClosing(WindowEvent e)
                     {System.exit(0);}
                     });
               
          pack();setSize(600,550);
    
          }
       public static void main(String args[]){
           Chess chess=new Chess();
       
      }
  }
  3.Evaluate：public class Evaluate{
      int max_x,max_y,max;
     
     
     
      public void evaluate(int shape[][][]){
         int i=0,j=0;
          
         for(i=0;i<19;i++)
           for(j=0;j<19;j++){
                                  
            
                  switch(shape[i][j][0]) {
                      case 5:
                          shape[i][j][4]=200;
                          break;
                      case 4:
                           switch(shape[i][j][1]){
                                case 4:
                                    shape[i][j][4]=150+shape[i][j][2]+
                                                       shape[i][j][3];
                                   
                                    break;   
                                case 3:
                                    shape[i][j][4]=100+
                                                      shape[i][j][2]+
                                                      shape[i][j][3];
                                    break;
                                default:
                                    shape[i][j][4]=50+
                                                      shape[i][j][2]+  
                                 shape[i][j][3];
                               
                           }
                           break;
                      case 3:
                            switch(shape[i][j][1]){
                                 case 3:
                                      shape[i][j][4]=75+
                                                      shape[i][j][2]+
                                                      shape[i][j][3];
                                       break;             
                                 default:
                                       shape[i][j][4]=20+
                                                      shape[i][j][2]+  
                                 shape[i][j][3];
                             }
                             break;
                     case 2:
                           shape[i][j][4]=10+shape[i][j][1]
                                                        +shape[i][j][2]  
                                   +shape[i][j][3];
                           break;
                     case 1:
                           shape[i][j][4]=shape[i][j][0]+shape[i][j][1]
                                                        +shape[i][j][2]  
                                   +shape[i][j][3];
                     default : shape[i][j][4]=0;                     
                    }  
               }      
      
       int x=0,y=0;
       max=0;
       for(x=0;x<19;x++)
           for(y=0;y<19;y++)
              if(max<shape[x][y][4]){  
                 max=shape[x][y][4]; 
                 max_x=x;max_y=y;}    
       }
  }
  4.Judge：public class Judge{
    
      static boolean judge(int a[][],int color){
     
        int i,j,flag;
        for(i=0;i<19;i++){
            flag=0;
            for(j=0;j<19;j++)
                if(a[i][j]==color){  
                   flag++;
                   if (flag==5)
                     return true;}
               else   flag=0;
           
        }         
        for(j=0;j<19;j++){
             flag=0;
             for(i=0;i<19;i++)
                 if(a[i][j]==color)
                 {flag++;
                 if(flag==5)
                     return true;}
                 else flag=0;
            }
        for(j=4;j<19;j++){
            flag=0;  int m=j;
            for(i=0;i<=j;i++){
             
              
               if(a[i][m--]==color){
                    flag++;
                    if(flag==5)
                    return true;}
                    else flag=0;}
            }         
        for(j=14;j>=0;j--){
            flag=0;  int m=j;
            for(i=0;i<=18-j;i++){
             
                if(a[i][m++]==color){
                    flag++;
                    if(flag==5)
                    return true;}
                    else flag=0;}
            }          
        for(i=14;i>=0;i--){
            flag=0;    int n=i;
            for(j=0;j<19-i;j++){
           
                if(a[n++][j]==color){
                    flag++;
                    if(flag==5)
                    return true;}
                    else flag=0;}
            }         
         for(j=14;j>=0;j--){
            flag=0; int m=j;
            for(i=18;i>=j;i--){
             
               if(a[i][m++]==color){
                    flag++;
                    if(flag==5)
                    return true;}
                    else flag=0;}
            }                
   
         return false;}  
     }
  5.Scan：public class Scan{
     
   
       int shape[][][]=new int[19][19][5];
   
      
       void scan(int chesspad[][],int colour){
          int i,j;
   
          for(i=0;i<=18;i++)
               for(j=0;j<=18;j++)
                    if(chesspad[i][j]==0){
                             int m=i,n=j;
                         
                         
                                    
                                 
                              
                                     while(n-1>=0&&chesspad[m][--n]==colour){
                                             shape[i][j][0]++;
                                            }
                                     n=j;
                                     while(n+1<=18&&chesspad[m][++n]==colour){
                                            shape[i][j][0]++;
                                            }
                                          
                                   
                                     n=j;
                                     while(m-1>=0&&chesspad[--m][n]==colour){
                                             shape[i][j][1]++;
                                            }
        m=i;
                                     while(m+1<=18&&chesspad[++m][n]==colour){
                                             shape[i][j][1]++;
                                            }
                                   
                                         
                                     m=i;
                                     while(m-1>=0&&n+1<=18&&chesspad[--m][++n]==colour){
                                             shape[i][j][2]++;
                                             }
                       m=i;n=j;
     while(m+1<=18&&n-1>=0&&chesspad[++m][--n]==colour){
                                              shape[i][j][2]++;
                                             }
                     
                                     m=i;n=j;
                                   
     while(m-1>=0&&n-1>=0&&chesspad[--m][--n]==colour){
                                             shape[i][j][3]++;
                                             }
                       m=i;n=j;
     while(m+1<=18&&n+1<=18&&chesspad[++m][++n]==colour){
                                             shape[i][j][3]++;
                                             }
     }    
  }    
  }
  6.   Sort： public class Sort{
   
   
    public void sort(int shape[][][]){
   
         int temp; 
         for(int i=0;i<19;i++)
           for(int j=0;j<19;j++){
                                  
                       for(int h=1;h<=4;h++){
                       for(int w=3;w>=h;w--){
                       if(shape[i][j][w-1]<shape[i][j][w]){
                       temp=shape[i][j][w-1];
                       shape[i][j][w-1]=shape[i][j][w];
                       shape[i][j][w]=temp;
                       }
                  }
              }
         }
     }
 
}

四丶程序截图：

五丶实验心得：

通过此次课程设计，将我本学期所学的java知识得到巩固和应用，在设计的过程中，我遇到了很多问题，不过在老师和同学们的帮助和自己的思考下得到了解决。在这次课程设计中,综合运用了知识，包括类的创建，构造方法和方法等知识。由于自己的分析设计和程序经验不足，该系统设计和实现过程有诸多不足，比如用户界面不够美观等等，这些有待进行进一步完善和提高。对于文中出现的不足和系统出现的问题，敬请老师指导。

源代码地址链接：https://github.com/zgw123    test目录下个人项目里

时间： 2024-09-30 21:09:07

软件工程——个人项目：五子棋的相关文章

关于软件工程第一次项目的一些感想

在奋斗了24+小时之后,终于完成了软件工程第一次项目.中间有很多曲折,也收获了很多经验. 预计完成时间:复习C++(一小时):构思(半小时):编码(四小时):调试(二小时):其他(半小时).合计(八小时). 实际完成时间:复习C++(两小时):构思(半小时):编码(三小时):调试(五小时+):优化(三小时).合计(十三小时+). 首先是审题方面. 这个要求里面最需要注意的有三点: 1.单词的构成,前三个必须是字母,后面可以接任意多的字母或数字,其他字符均视为分隔符. 2.忽略大小写 3.123f

对于软件工程整个项目的自我感受

软件工程是一门研究用工程化方法构建和维护有效的.实用的和高质量的软件的学科.整个软件开发过程分为问题定义->可行性研究->需求分析->概要设计->详细设计->编码->测试->运行维护计算机软件等步骤(摘自百度知道). 软件工程的学习,是一块大项目,具体通过项目的制作实现,通过项目学习该门课程也是老师给我们的任务. 就目前的学习情况来看,软件工程在项目开发前的准备,开发时的设计和开发后的维护,都是一套需要一起考虑到的,所以,软件工程不单单是一个软件制作,更是软件设计

【目标】我的软件工程实践项目

1.这次的软件工程实践项目是要我们开发移动应用的软件,而我本人对于Android较感兴趣,所以对到最后能学习到的能力的预期当然是: · 有能力独自开发能稳定运行功能简单的应用,比如教务处查成绩软件等: · 懂得如何团队协作,想要开发功能稳定,强大的软件,单干肯定不行,所以要积累团队协作的经验: · 当然,如果有能力,能顺便了解下IOS或微信的开发自然最好. 2.而对课程的期望:希望老师能先给我们规划好大概的学习方向,让我们知道从哪开始入手学习,学习哪个方向的知识,不至于走太多歪路.当然,学习过程

现代软件工程团队项目贝塔阶段_开发日志_2018.01.15-2018.01.19

现代软件工程团队项目贝塔阶段_开发日志_2018.01.15-2018.01.19 2018.01.15 已完成: 1.版本上线 1.1上线操作步骤 1.1.1将网站整体文件夹拷贝到keqi1 1.1.2修改microDefinition.php的数据库名和根目录名 1.1.3修改注册界面发送验证码后直接填充功能 1.1.4修改del的主id的class为hide 1.1.5重新运行根目录的111.php(消除红点,也就是消除服务器返回的多余字符) 1.2修复上线过程中遇到的bug  1.2.1

软件工程团队项目总结

一学期软件工程课结束了,这学期我们共做了三个项目,分别为个人项目.结对项目.以及团队大项目.前两者主要是拿来练手,体会一下简单的软件工程方法论,而结对项目前后历时两个多月,可以说是一次系统的软件工程锻炼,下面对两个迭代过程做一个总结. M1: 我们完成了什么:一个社团平台,给同学提供一个浏览社团活动的活动广场,给社团提供一个管理社员报名和发送通知的集成服务. 我们怎样做到的:需求分析,设想我们的产品的用户场景,建立基本的ER图模型,学习WEB开发的基本知识,做了一些DEMO,学习怎样以基于aja

软件工程之项目序曲

我是刘峻琳,来自山城重庆.自古智者乐水,仁者乐山,有幸生在一个面山环水的地方,我也希望能水一样灵动,像山一样沉稳……呃,太正经了.总的来说,我的性格属于折中型的,能和死党开没羞没臊的玩笑,但更加喜欢深度的思考,说好听一点叫内外兼修,说难听一点叫个性不够鲜明.不过,我自己倒是对自己的性格还算满意吧. 技术上,由于有中学阶段的竞赛背景,所以对各类算法和数据结构较为熟悉,也算是一个老年程序猿了吧.然而在我看来,目前我们所接触的软件开发事实上对算法和数据结构的要求并不高,更多的是利用现有的框架结构.工具

安卓项目五子棋代码详解（五）

这一期给大家带来我自己添加的功能,最近还搞了个播放背景音乐和下棋音效,与这个一起讲了 开笔之前,忽然响起还有一个保存游戏没讲,真是失误. 保存游戏呢,就是将当前棋子的位置都保存下来,我们可以设想一个情景,玩家玩着游戏的时候,忽然一个电话过来,就会跳转到打电话的界面,或者一条QQ消息要处理,玩家跳转到了QQ的界面处理消息,待他处理完之后,就会返回游戏,如果我们没有设置保存游戏的这个方法的话,那么玩家再次进入的时候就是跟开始的一样,这样的体验非常糟糕,所以保存游戏这个方法是必须要有的. 首先在Pan

[个人博客作业Week7]软件工程团队项目感想与反思

在阅读了推荐阅读的材料之后,我想了很多东西.最终还是决定,以团队项目的经历为主线,叙述我关于软件工程的一些思考与体会. 凤凰涅槃,浴火重生 如果要我来概况这几周团队项目的经历的话,那么句话是我所能想到的最贴切的一个表述.从最初的雄心壮志,到中间的困顿不堪,再到目前如重生一般的喜悦,我们整个团队经历了太多太多. 重造轮子 轮子,在软件行业中经常指那些设计好的,用于处理常见功能的库.框架或者可重用的代码.而重造轮子则是说,在已经有可用的“轮子”的情况下,自己重新实现一个自己的“轮子”.有些人经常说,

实践作业3 结对项目--五子棋项目

一:题目简介: 五子棋及其实现的功能: 1.实现人人对战,可获取棋盘上所有棋子个数,同一点处只能存放一枚棋子. 2声音的加入. 3.设置悔棋功能. 4.提供游戏说明. 5.实现游戏的重新开始. 6.设置排行榜功能,获胜者可将个人信息存入排行榜中 同时玩家也可自行查看排行榜内具体信息. 7.榜单的清除功能 8.设置存盘读盘的功能,可保留并继续进行上一局棋局. 二:分工: 王金涛: 基本窗体(awt)的构建.声音的加入 郭宇: 算法的设计,监听的加入(actionListener,windowLis