码迷,mamicode.com
首页 > 其他好文 > 详细

20135115臧文君---实验3

时间:2015-06-05 00:31:44      阅读:139      评论:0      收藏:0      [点我收藏+]

标签:

北京电子科技学院(BESTI)

实     验    报     告

课程:Java    班级:1351班      姓名:臧文君    学号:20135115

成绩:             指导教师:娄嘉鹏       实验日期:2015.6.4

实验密级:无       预习程度:           实验时间:15:30-18:00

仪器组次:         必修/选修:选修     实验序号:二

实验名称:  敏捷开发与XP实践                                                   

实验目的与要求: 1.没有Linux基础的同学建议先学习《Linux基础入门(新版)》《Vim编辑器》 课程。

2.完成实验、撰写实验报告,实验报告以博客方式发表在博客园,注意实验报告重点是运行结果,遇到的问题(工具查找,安装,使用,程序的编辑,调试,运行等)、解决办法(空洞的方法如“查网络”、“问同学”、“看书”等一律得0分)以及分析(从中可以得到什么启示,有什么收获,教训等)。报告可以参考范飞龙老师的指导

3. 严禁抄袭,有该行为者实验成绩归零,并附加其他惩罚措施。

实验仪器:

名称

型号

数量

笔记本电脑

Lenovo Z485

1台

 

 

 

 

实验内容、步骤与体会(附纸):

一、实验内容

1. XP基础

2. XP核心实践

3. 相关工具

4.结对同学:20135207 王国伊

Blog网址:www.cnblogs.com/20135207oneking

 

二、实验步骤

(一)敏捷开发与XP

1、软件工程

(1)包括:软件需求分析、软件设计、软件构建、软件测试和软件维护。

(2)软件工程=开发流程+工具。

     软件=程序+软件工程,软件企业=软件+商业模式。

(3)常见的开发流程:

RUP(Rational Unified Process)

PSP(Personal Software Process )

TSP(Team Software Process )

Agile Process

2、敏捷开发(Agile Development)

(1)含义:是一种以人为核心、迭代、循序渐进的开发方法。

(2)模式:XP,TDD,CI,FDD,BDD,SCRUM,Feature Team,Domain Model,Extract Activities,Refactor,Pair Programming,Feature List/Product Backlog.

(3)极限编程(eXtreme Programming,XP) 是一种全新而快捷的软件开发方法。

(4)XP准则:沟通,简单,反馈,勇气。

(5)XP活动:编码,测试,倾听,设计。

 

(二)编码标准

1、包含:具有说明性的名字、清晰的表达式、直截了当的控制流、可读的代码和注释,以及在追求这些内容时一致地使用某些规则和惯用法的重要性。

2、Eclipse中的快捷键使用:

Ctrl+Shift+F或菜单中的source->Format,使代码按Eclipse规定的规范缩进。

技术分享

技术分享 3、Java中的一般的命名规则:

(1)要体现各自的含义;

(2)包、类、变量用名词;

(3)方法名用动宾;

(4)包名全部小写,如:io,awt;

(5)类名第一个字母要大写,如:HelloWorldApp;

(6)变量名第一个字母要小写,如:userName;

(7)方法名第一个字母要小写:setName。

4、标识符

一般采用英文单词或其组合,切忌使用汉语拼音来命名,可以通过去元音法把变量名缩短。

 

(三)结对编程

1、分为:驾驶员(Driver)是控制键盘输入的人。

领航员(Navigator)起到领航、提醒的作用。

2、驾驶员:写设计文档,进行编码和单元测试等XP开发流程。

   领航员:审阅驾驶员的文档、驾驶员对编码等开发流程的执行;考虑单元测试的覆盖率;思考是否需要和如何重构;帮助驾驶员解决具体的技术问题。

 

(四)版本控制

1、版本控制提供项目级的 undo(撤销) 功能。

2、版本控制允许多人在同一代码上工作, 只要遵守一定的控制原则就行。

3、版本控制系统保存了过去所作的修改的历史记录。

4、版本控制系统还支持在主线上开发的同时发布多个软件版本。

5、版本控制也是项目级的时间机器,你可以选择任何一个时间, 精确地查看项目在当时的情况。

6、流行的版本控制工具有CVS,SVN,Git等。

7、实验楼中的git服务:

(1)公开的代码仓库:shiyanlou_cs212

(2)启动实验时,会自动执行git pull,获取课程仓库中的最新代码,存放于/home/shiyanlou/Code目录。

(3)进入到实验环境中修改代码,完成后需要依次执行下述命令即可提交:

$ cd /home/shiyanlou/Code/shiyanlou_cs212

# 修改代码文件

# 添加修改文件

$ git add 所有修改的文件

# 提交到环境中本地代码仓库

$ git commit -m ‘本次修改的描述‘

# push到git.shiyanlou.com,无需输入密码

$ git push

例:

技术分享

技术分享 技术分享

 (4)克隆其他用户代码仓库只需要知道对方的仓库链接,我们鼓励在别人代码基础上修改:

$ git clone http://git.shiyanlou.com/[对方的专属用户名]/[课程代码仓库名]

(5)输入git status:查看代码状态;

     出现未跟踪的文件,使用git add <file>...:以包含要提交的内容;

     使用git commit:git将依据索引库中的内容来进行文件的提交;

     使用git push:把代码保存到远程托管服务器中。

 

(五)重构(Refactor)

1、概念:重构是在不改变软件外部行为的基础上,改变软件内部的结构,使其更加易于阅读、易于维护和易于变更。

2、重构的第一项功能---Rename

可以给类、包、方法、变量改名字。

修改方法:用鼠标单击要改的名字,选择Eclipse中菜单中的Refactor->Rename...

例:

技术分享

技术分享 3、重构的第二项功能---封装

修改方法:Refactor->Encapsulate Field...

例:

技术分享

选择需要封装的变量s.name,点击Refactor->Encapsulate Field。

技术分享

用同样的方法封装age和id。

技术分享 

使用Eclipse中Source->Generate toString(),给Student类产生一个toString方法。

技术分享

4、修改代码的目的:

增加新功能,原有功能有BUG,改善原有程序的结构,优化原有系统的性能。

5、有Bad Smell的代码需要重构:

重复代码(Duplicated Code),过长方法,过长参数列,条件逻辑过度复杂,分支语句,基本类型迷恋,数据泥团。

6、Eclipse中Refactor菜单中的重构手法的应用时机如下图所示:

 技术分享

7、重构的完整流程:

(1)从版本控制系统代码库中Check out code;

(2)读懂代码(包括测试代码);

(3)发现bad smell;

(4)Refactoring;

(5)运行所有的Unit Tests;

(6)往代码库中Check in code;

 

(六)实践项目

编写小游戏:黑白棋。

结对同学:20135207 王国伊

Blog网址:www.cnblogs.com/20135207oneking

1、实验分工:臧文君---代码分析,Chess、ChessListener代码的重构。

             王国伊---代码分析,GUI界面的实现。

2、实验步骤:

(1)先查找黑白棋的游戏规则,分析代码需要实现的内容:

a.下棋子时相应的棋子颜色改变;

b.统计黑白双方现有棋子的个数以及每下一步改变棋子的个数;

c.分析棋手还有几种下发。

(2)在网上搜索相关代码,克隆下来。

(3)分析代码中语句的功能,进行代码测试。

(4)根据测试结果,由臧文君负责代码中变量名称、方法的重构,由王国伊负责GUI界面的实现。

(5)将两个人的代码进行综合,测试结果。

3、黑白棋游戏代码:

import java.awt.Dimension; 

import java.awt.Font; 

import java.awt.Graphics; 

import java.awt.GridLayout; 

import java.awt.Image; 

import java.awt.event.ActionEvent; 

import java.awt.event.ActionListener; 

import javax.swing.ImageIcon; 

import javax.swing.JButton; 

import javax.swing.JFrame; 

import javax.swing.JLabel; 

import javax.swing.JPanel; 

@SuppressWarnings("serial")

 

public class Chess extends JFrame { 

    public static void main(String args[]){ 

        Chess ch = new Chess(); 

        ch.showframe(); 

    }

   

    //显示游戏界面 

    public void showframe(){ 

        //--------------------游戏界面---------------------- 

        JPanel gamejp = new JPanel(); 

        //--------------------组件界面---------------------- 

        JPanel buttonjp = new JPanel(); 

        //按钮图标 

        ImageIcon blackchess = new ImageIcon("E:/JavaCode/Test/Test/image/黑子.jpg"); 

        ImageIcon whitechess = new ImageIcon("E:/JavaCode/Test/Test/image/白子.jpg"); 

        ImageIcon black = new ImageIcon("E:/JavaCode/Test/Test/image/黑子.jpg");

        ImageIcon white = new ImageIcon("E:/JavaCode/Test/Test/image/白子.jpg"); 

        JButton blackbutton = new JButton(blackchess); 

        JButton whitebutton = new JButton(whitechess); 

        blackbutton.setRolloverIcon(black); 

        whitebutton.setRolloverIcon(white); 

        blackbutton.setPressedIcon(black); 

        whitebutton.setPressedIcon(white); 

        Dimension di = new Dimension(100,100); 

        blackbutton.setPreferredSize(di); 

        whitebutton.setPreferredSize(di);

       

        //-----------------------当前下棋的人--------------------- 

        final JLabel record = new JLabel(" 黑方下  "); 

        //设置字体 

        Font recordfont = new Font("黑体",Font.BOLD,30); 

        record.setFont(recordfont); 

        //用来记录阿狸与桃子的数目 

        final JLabel blacknum = new JLabel("2");

        final JLabel whitenum = new JLabel("2"); 

        //设置Label的字体和大小 

        Font font = new Font("宋体",Font.BOLD,42); 

        blacknum.setFont(font); 

        whitenum.setFont(font);

       

        //-----------------重新开局的方法------------------ 

        ImageIcon img = new ImageIcon("E:/JavaCode/Test/Test/image/restart.jpg"); 

        JButton bu = new JButton(img); 

        bu.setPreferredSize(new Dimension(100,40)); 

        buttonjp.add(record); 

        buttonjp.add(blackbutton); 

        buttonjp.add(blacknum); 

        buttonjp.add(whitebutton); 

        buttonjp.add(whitenum); 

        buttonjp.add(bu); 

        this.setLayout(new GridLayout(1,2,600,0)); 

        this.add(gamejp); 

        this.add(buttonjp); 

        this.setTitle("黑白棋--双人对战"); 

        this.setSize(1000,650); 

        this.setResizable(false); 

        this.setLocationRelativeTo(null); 

        this.setDefaultCloseOperation(3);

       

        //显示窗口 

        this.setVisible(true);

       

        //获取画布权限 

        Graphics g = this.getGraphics(); 

        chess[3][3]=1; 

        chess[4][4]=1; 

        chess[3][4]=-1; 

        chess[4][3]=-1; 

        ChessListener listener = new ChessListener(g,this,record,blacknum,whitenum); 

        this.addMouseListener(listener);

       

        //按钮监听器----------------重新开始 

        ActionListener buttonlistener = new ActionListener(){ 

            public void actionPerformed(ActionEvent e){ 

                clear(); 

                //重绘的方法 

                repaint(); 

                //绘制初始的四个图片 

                chess[3][3]=1; 

                chess[4][4]=1; 

                chess[3][4]=-1; 

                chess[4][3]=-1; 

                //将状态改为初始状态 

                ChessListener.stata=1; 

                record.setText(" 黑方下  "); 

                blacknum.setText("2"); 

                whitenum.setText("2"); 

            } 

        };

       

        //如果点击黑方则黑方下 

        ActionListener blacklistener = new ActionListener(){ 

            public void actionPerformed(ActionEvent e){ 

                ChessListener.stata=1; 

                record.setText(" 黑方下 "); 

            } 

        }; 

        //如果点击白方则白方下 

        ActionListener whitelistener = new ActionListener(){ 

            public void actionPerformed(ActionEvent e){ 

                ChessListener.stata=-1; 

                record.setText(" 白方下  "); 

            } 

        };

       

        blackbutton.addActionListener(blacklistener); 

        whitebutton.addActionListener(whitelistener); 

        bu.addActionListener(buttonlistener); 

    } 

   

    public void clear(){ 

        for(int i=0;i<chess.length;i++){ 

            for(int j=0;j<chess[i].length;j++){ 

                chess[i][j]=0; 

            } 

        } 

    } 

 

    public void paint(Graphics g){ 

        super.paint(g); 

        Image back = new ImageIcon("E:/JavaCode/Test/Test/image/棋盘.jpg").getImage(); 

        g.drawImage(back, 10,30,600,600, null); 

 

        //绘制棋子 

        for(int i=0;i<rows-1;i++){ 

            for(int j=0;j<cols-1;j++){ 

                int X=x+size/2+size*i;//棋子的横坐标 

                int Y=y+size/2+size*j;//棋子的纵坐标 

                if(chess[i][j]==1){ 

                    //画黑棋 

                    Image b = new ImageIcon("E:/JavaCode/Test/Test/image/黑子.jpg").getImage(); 

                    g.drawImage(b, X-Chess_size/2, Y-Chess_size/2, Chess_size, Chess_size, null);  

                } 

                else if(chess[i][j]==-1){ 

                    //画白棋 

                    Image w = new ImageIcon("E:/JavaCode/Test/Test/image/白子.jpg").getImage(); 

                    g.drawImage(w, X-Chess_size/2, Y-Chess_size/2, Chess_size, Chess_size, null);

                } 

            } 

        } 

    }

   

    public final static int x=63;   //棋盘初始点横坐标 

    public final static int y=85;   //棋盘初始点纵坐标 

    public final static int rows=9; //棋盘行数 

    public final static int cols=9; //棋盘列数 

    public final static int size=61;//棋盘格子大小 

    public final static int Chess_size=60;//棋子大小 

    public final static int chess[][]=new int[rows-1][cols-1];//定义一个8*8的数组,用来保存棋子 

}

 

 

 

import java.awt.Graphics; 

import java.awt.event.MouseAdapter; 

import java.awt.event.MouseEvent; 

import javax.swing.JLabel; 

import javax.swing.JOptionPane; 

 

public class ChessListener extends MouseAdapter{ 

    private Graphics g;        //将画布对象传过来 

    private int skill;         //记录当前棋子的下法 

    public  static int stata=1;//判断下黑棋还是白棋

    private int x1,y1;         //记录点击处的横坐标和纵坐标 

    private JLabel record;       //当前下棋子的人 

    private JLabel blacknum;      //黑方棋子数 

    private JLabel whitenum;    //白方棋子数 

    private Chess ch;          //用来刷新棋盘 

    private int   special=0;        //特殊情况 

    private int   change;      //记录改变的棋子数目 

    public ChessListener(Graphics g,Chess ch,JLabel record,JLabel blacknum,JLabel whitenum){ 

       this.g=g; 

       this.ch=ch; 

       this.record=record; 

       this.blacknum=blacknum; 

       this.whitenum=whitenum; 

    } 

 

    //点击下棋子 

    public void mouseClicked(MouseEvent e){ 

       int a=1;            //记录所下的子 

       String s = null;        

       x1=e.getX(); 

       y1=e.getY(); 

       for(int i=0;i<Chess.rows-1;i++){ 

           for(int j=0;j<Chess.cols-1;j++){ 

              int x2=Chess.x+Chess.size/2+Chess.size*i;//得到棋盘中棋子所在点的横坐标 

              int y2=Chess.y+Chess.size/2+Chess.size*j;//得到棋盘中棋子所在点的纵坐标 

              //将棋子下在棋盘格子的正中央 

              if(Math.abs(x1-x2)<Chess.size/3&&Math.abs(y1-y2)<Chess.size/3){ 

                  if(Chess.chess[i][j]==0){ 

                     if(stata==1)  

                         stata=-1;

                     else if(stata==-1)

                         stata=1;

                     Chess.chess[i][j]=-stata;//将棋子存入棋盘 

                    

                     //--------------如果8个方向都不能改变棋子则不改变棋盘状态-------------- 

                     if (hengYou(i, j) == null && hengZuo(i, j) == null && hengShang(i, j) == null && hengXia(i, j) == null && xieyouS(i, j) == null && xieyouX(i, j) == null && xiezuoS(i, j) == null && xiezuoX(i, j) == null) { 

                         Chess.chess[i][j]=0; 

                         if(stata==1){ 

                            stata=-1; 

                         } 

                         else if(stata==-1){ 

                            stata=1; 

                         } 

                         //刷新棋盘 

                         ch.update(g); 

                         JOptionPane.showMessageDialog(null, "不能放子"); 

                     } 

                     else{ 

                         // 改变中间子颜色 

                         hengYou1(i, j); 

                         hengZuo1(i, j); 

                         hengShang1(i, j); 

                         hengXia1(i, j); 

                         xieyou1(i, j); 

                         xieyou2(i, j); 

                         xiezuo1(i, j); 

                         xiezuo2(i, j); 

                         // 以坐标为圆心画圆  

                         ch.update(g); 

                         //改变棋子记录框里面的数字 

                         blacknum.setText(judge()[0]+""); 

                         whitenum.setText(judge()[1]+""); 

                         System.out.println("改变了"+change+"个子"); 

                         change=0; 

                         //判断当前下棋的人 

                         if(stata==1){ 

                            record.setText(" 黑方下  "); 

                            a=1; 

                            s="黑方"; 

                         } 

                         else if(stata==-1){ 

                            record.setText(" 白方下  "); 

                            a=-1; 

                            s="白方"; 

                         } 

                         skill=Check(a);

                        

                         //输出当前下棋的人还有几种下法 

                         System.out.println(s+"有"+skill+"种下法"); 

                         if(skill==0&&full()==false){//如果不能下子并且棋盘未满 

                            special++; 

                            JOptionPane.showMessageDialog(null, s+"不能下子,跳过!"); 

                            if(stata==1){//如果黑方不能下子则跳过,白方下 

                                stata=-1; 

                                record.setText(" 白方下  "); 

                                a=-1; 

                                s="白方"; 

                            } 

                            else if(stata==-1){//如果白方不能下子则跳过,黑方下 

                                stata=1; 

                                record.setText(" 黑方下  "); 

                                a=1; 

                                s="黑方"; 

                            } 

                            skill=Check(a); 

                            System.out.println(s+"有"+skill+"种下法"); 

                            if(skill==0){ 

                                special++;//如果无子可下,则特殊情况记录加1 

                            }else

                                special=0; 

                         }

                        

                         //----------------胜负判断---------------- 

                         if(judge()[0]==0){//如果黑方没子了则白方获胜 

                            JOptionPane.showMessageDialog(null,"游戏结束,白方获胜"); 

                         } 

                         else if(judge()[1]==0){//如果白方没子了则黑方获胜 

                            JOptionPane.showMessageDialog(null, "游戏结束,黑方获胜"); 

                         } 

                         if(full()){ 

                            if(judge()[0]>judge()[1]){//如果黑方的子较多,则黑方获胜 

                                JOptionPane.showMessageDialog(null, "游戏结束,黑方获胜"); 

                            } 

                            else if(judge()[0]<judge()[1]){//如果白方的子较多,则白方获胜 

                                JOptionPane.showMessageDialog(null, "游戏结束,白方获胜"); 

                            } 

                            else if(judge()[0]==judge()[1]){ 

                                JOptionPane.showMessageDialog(null, "平局"); 

                            } 

                         } 

                     } 

                  }

              } 

           } 

       } 

    } 

 

    /* 判断输赢的方法,如果黑棋多则黑棋获胜,否则白棋获胜

       @return 黑棋和白棋的数目     */

    public int[] judge(){ 

       int count[]=new int[2]; 

       for(int i=0;i<Chess.rows-1;i++){ 

           for(int j=0;j<Chess.cols-1;j++){ 

              if(Chess.chess[i][j]==1){ 

                  count[0]++; 

              } 

              else if(Chess.chess[i][j]==-1){ 

                  count[1]++; 

              } 

           } 

       } 

       return count; 

    } 

 

    /* 判断棋盘是否已满的方法   */

    public boolean full(){ 

       if(special==2){      //如果双方都不能下子,则游戏结束 

           return true; 

       } 

       else{ 

           for(int i=0;i<Chess.rows-1;i++){ 

              for(int j=0;j<Chess.cols-1;j++){ 

                  //如果有一个地方是空的则返回false 

                  if(Chess.chess[i][j]==0){ 

                     return false; 

                  } 

              } 

           } 

       } 

       return true; 

    } 

 

    /*  判断当前棋子的下法还有多少种

        @param return 返回下法的总数     */

    public int Check(int a){ 

       int n=0; 

       for(int i=0;i<Chess.chess.length;i++){ 

           for(int j=0;j<Chess.chess[i].length;j++){ 

              if(Chess.chess[i][j]!=0){ 

                  continue; 

              } 

              else{ 

                  Chess.chess[i][j]=a; 

                  if(hengYou(i, j) != null || hengZuo(i, j) != null || hengShang(i, j) != null || hengXia(i, j) != null || xieyouS(i, j)   != null || xieyouX(i, j) != null || xiezuoS(i, j)   != null || xiezuoX(i, j) != null){ 

                     Chess.chess[i][j]=0; 

                     n++;                //如果有一个地方可以下子,则n+1 

                  } 

                  else{ 

                     Chess.chess[i][j]=0; 

                  }

              }

           }

       }

       return n;

    }

 

    /*********************************************** 检测相同颜色 *******************************/

    /* 改变两棋子之间的棋子的颜色——直线   */

    public void paintChess(int r1, int c1, int r2, int c2) { 

       // 横向 

       if (c1 == c2) { 

           for (int k = Math.min(r1, r2) + 1; k < Math.max(r1, r2); k++) { 

              Chess.chess[k][c1] = Chess.chess[r1][c1]; 

              change++; 

           } 

       } 

       // 纵向 

       if (r1 == r2) { 

           for (int k = Math.min(c1, c2) + 1; k < Math.max(c1, c2); k++) { 

              Chess.chess[r1][k] = Chess.chess[r1][c1]; 

              change++; 

           } 

       } 

    } 

 

    /* 改变两棋子之间的棋子的颜色——斜线——右上    */

    public void paintChess1(int r1, int c1, int r2, int c2) { 

       for (int k = Math.min(r1, r2) + 1, v = Math.max(c1, c2) - 1; k < Math 

              .max(r1, r2); k++, v--) { 

           Chess.chess[k][v] = Chess.chess[r1][c1]; 

           change++; 

       } 

    } 

 

    /* 改变两棋子之间的棋子的颜色——斜线——右下  */

    public void paintChess2(int r1, int c1, int r2, int c2) { 

       for (int k = Math.min(r1, r2) + 1, v = Math.min(c1, c2) + 1; k < Math 

              .max(r1, r2); k++, v++) { 

           Chess.chess[k][v] = Chess.chess[r1][c1]; 

           change++; 

       } 

    } 

 

    /* 改变两棋子之间的棋子的颜色——斜线——左上    */

    public void paintChess3(int r1, int c1, int r2, int c2) { 

       for (int k = Math.max(r1, r2) - 1, v = Math.max(c1, c2) - 1; k > Math 

              .min(r1, r2); k--, v--) { 

           Chess.chess[k][v] = Chess.chess[r1][c1]; 

           change++; 

       } 

    } 

 

    /* 改变两棋子之间的棋子的颜色——斜线——左下    */

    public void paintChess4(int r1, int c1, int r2, int c2) { 

       for (int k = Math.min(r1, r2) + 1, v = Math.max(c1, c2) - 1; k <= Math 

              .max(r1, r2); k++, v--) { 

           Chess.chess[k][v] = Chess.chess[r1][c1]; 

           change++; 

       } 

    } 

 

    /* 向右检测是否有相同颜色棋子,如果有且不相邻,改变中间棋子颜色,否则返回NULL  */

    public int[] hengYou(int x, int y) { 

       int r = -2; 

       int i; 

       // 向右 

       for (i = x + 1; i < Chess.rows-1; i++) { 

           if (Chess.chess[i][y] != 1 && Chess.chess[i][y] != -1)

              break;

           if (Chess.chess[i][y] == Chess.chess[x][y]) { 

              r = i; 

              break; 

           } 

       } 

       if (r != -2 && Chess.chess[x + 1][y] != Chess.chess[i][y]) { 

           return new int[] { r, y }; 

       }

       else

           return null;

    } 

 

    /* 向左检测是否有相同颜色棋子,如果有且不相邻,改变中间棋子颜色,否则返回NULL  */

    public int[] hengZuo(int x, int y) { 

       int r = -2; 

       int i; 

       // 向左 

       for (i = x - 1; i >= 0; i--) { 

           if (Chess.chess[i][y] != 1 && Chess.chess[i][y] != -1) { 

              break; 

           } 

           if (Chess.chess[i][y] == Chess.chess[x][y]) { 

              r = i; 

              break; 

           } 

       } 

       if (r != -2 && Chess.chess[x - 1][y] != Chess.chess[i][y]) { 

 

           return new int[] { r, y }; 

       }

       else 

           return null;

    } 

 

    /* 向上检测是否有相同颜色棋子,如果有且不相邻,改变中间棋子颜色,否则返回NULL  */

    public int[] hengShang(int x, int y) { 

       int r = -2; 

       int i; 

       // 向上 

       for (i = y - 1; i >= 0; i--) { 

           if (Chess.chess[x][i] == 0)

              break;

           if (Chess.chess[x][i] == Chess.chess[x][y]) { 

              r = i; 

              break; 

           } 

       } 

       if (r != -2 && Chess.chess[x][y - 1] != Chess.chess[x][i]) { 

 

           return new int[] { x, r }; 

       }

       else

           return null;

    } 

 

    /* 向上检测是否有相同颜色棋子,如果有且不相邻,改变中间棋子颜色,否则返回NULL  */

    public int[] hengShang1(int x, int y) { 

       int r = -2; 

       int i; 

       // 向上 

       for (i = y - 1; i >= 0; i--) { 

           if (Chess.chess[x][i] == 0)

              break;

           if (Chess.chess[x][i] == Chess.chess[x][y]) { 

              r = i; 

              break; 

           } 

       } 

       if (r != -2 && Chess.chess[x][y - 1] != Chess.chess[x][i]) { 

           // 改变中间的子 

           paintChess(x, y, x, r); 

           return new int[] { x, r }; 

       }

       else

           return null;

    } 

 

    /* 向下检测是否有相同颜色棋子,如果有且不相邻,改变中间棋子颜色,否则返回NULL */

    public int[] hengXia(int x, int y) { 

       int r = -2; 

       int i; 

       // 向下 

       for (i = y + 1; i < Chess.rows-1; i++) { 

           if (Chess.chess[x][i] == 0)

              break;

           if (Chess.chess[x][i] == Chess.chess[x][y]) { 

              r = i; 

              break; 

           } 

       } 

 

       if (r != -2 && Chess.chess[x][y + 1] != Chess.chess[x][i]) { 

           return new int[] { x, r }; 

       }

       else

           return null;

    } 

 

    /* 向下检测是否有相同颜色棋子,如果有且不相邻,改变中间棋子颜色,否则返回NULL */

    public int[] hengXia1(int x, int y) { 

       int r = -2; 

       int i; 

       // 向下 

       for (i = y + 1; i < Chess.rows-1; i++) { 

           if (Chess.chess[x][i] == 0)

              break;

           if (Chess.chess[x][i] == Chess.chess[x][y]) { 

              r = i; 

              break; 

           } 

       } 

       if (r != -2 && Chess.chess[x][y + 1] != Chess.chess[x][i]) { 

           // 改变中间的子 

           paintChess(x, y, x, r); 

           return new int[] { x, r }; 

       }

       else

           return null;

    } 

 

    /* 斜右上方向    */

    public int[] xieyouS(int x, int y) { 

       // 向上 

       int r = -2, s = -2; 

       int i, j; 

       for (i = x + 1, j = y - 1; i < Chess.rows-1 && j >= 0; i++, j--) { 

           if (Chess.chess[i][j] == 0)

              break;  

           if (Chess.chess[i][j] == Chess.chess[x][y]) { 

              r = i; 

              s = j; 

              break; 

           } 

       } 

       if (r != -2 && s != -2 && Chess.chess[x + 1][y - 1] != Chess.chess[i][j]) { 

           return new int[] { r, s }; 

       }

       else

           return null;

    } 

 

    /* 斜右下方向   */

    public int[] xieyouX(int x, int y) { 

       // 向下 

       int r = -2, s = -2; 

       int i, j; 

       for (i = x + 1, j = y + 1; i < Chess.rows-1 && j < Chess.cols-1; i++, j++) { 

           if (Chess.chess[i][j] == 0)

              break;   

           if (Chess.chess[i][j] == Chess.chess[x][y]) { 

              r = i; 

              s = j; 

              break; 

           } 

       } 

       if (r != -2 && s != -2

              && Chess.chess[x + 1][y + 1] != Chess.chess[i][j]) { 

           return new int[] { r, s }; 

       }

       else 

           return null; 

    } 

 

    /* 斜左上方向    */

    public int[] xiezuoS(int x, int y) { 

       // 向上 

       int r = -2, s = -2; 

       int i, j; 

       for (i = x - 1, j = y - 1; i >= 0 && j >= 0; i--, j--) { 

           if (Chess.chess[i][j] == 0)

              break; 

           if (Chess.chess[i][j] == Chess.chess[x][y]) { 

              r = i; 

              s = j; 

              break; 

           } 

       } 

       if (r != -2 && s != -2 && Chess.chess[x - 1][y - 1] != Chess.chess[i][j]) { 

           return new int[] { r, s }; 

       }

       else

           return null; 

    } 

 

    /* 斜左下方向    */

    public int[] xiezuoX(int x, int y) { 

       // 向下 

       int r = -2, s = -2; 

       int i, j; 

       for (i = x - 1, j = y + 1; i >= 0 && j < Chess.cols-1; i--, j++) { 

           if (Chess.chess[i][j] == 0)

              break; 

           if (Chess.chess[i][j] == Chess.chess[x][y]) { 

              r = i; 

              s = j; 

              break; 

           } 

       } 

       if (r != -2 && s != -2 && Chess.chess[x - 1][y + 1] != Chess.chess[i][j]) { 

           return new int[] { r, s }; 

       }

       else

           return null;

    }

 

    /* 向右检测是否有相同颜色棋子,如果有且不相邻,改变中间棋子颜色,否则返回NULL  */

    public int[] hengYou1(int x, int y) { 

       int r = -2; 

       int i; 

       // 向右 

       for (i = x + 1; i < Chess.cols-1; i++) { 

           if (Chess.chess[i][y] != 1 && Chess.chess[i][y] != -1)

              break;

           if (Chess.chess[i][y] == Chess.chess[x][y]) { 

              r = i; 

              break; 

           } 

       } 

       if (r != -2 && Chess.chess[x + 1][y] != Chess.chess[i][y]) { 

           // 改变中间的子 

           paintChess(x, y, r, y); 

           return new int[] { r, y }; 

       }

       else

           return null; 

    } 

 

    /* 向左检测是否有相同颜色棋子,如果有且不相邻,改变中间棋子颜色,否则返回NULL */

    public int[] hengZuo1(int x, int y) { 

       int r = -2; 

       int i; 

       // 向左 

       for (i = x - 1; i >= 0; i--) { 

           if (Chess.chess[i][y] != 1 && Chess.chess[i][y] != -1)

              break;

           if (Chess.chess[i][y] == Chess.chess[x][y]) { 

              r = i; 

              break; 

           } 

       } 

       if (r != -2 && Chess.chess[x - 1][y] != Chess.chess[i][y]) { 

           // 改变中间的子 

           paintChess(x, y, r, y); 

           return new int[] { r, y }; 

       }

       else

           return null; 

    } 

 

    /* 斜右上方向    */

    public int[] xieyou1(int x, int y) { 

       // 向上 

       int r = -2, s = -2; 

       int i, j; 

       for (i = x + 1, j = y - 1; i < Chess.rows-1 && j >= 0; i++, j--) { 

           if (Chess.chess[i][j] == 0)

              break;

           if (Chess.chess[i][j] == Chess.chess[x][y]) { 

              r = i; 

              s = j; 

              break; 

           } 

       } 

       if (r != -2 && s != -2 && Chess.chess[x + 1][y - 1] != Chess.chess[i][j]) { 

           // 改变中间的子 

           paintChess1(x, y, i, j); 

           return new int[] { r, s }; 

       }

       else

           return null;

    } 

 

    /*  斜右下方向    */

    public int[] xieyou2(int x, int y) { 

       // 向下 

       int r = -2, s = -2; 

       int i, j; 

       for (i = x + 1, j = y + 1; i < Chess.rows-1 && j < Chess.cols-1; i++, j++) { 

           if (Chess.chess[i][j] == 0)

              break;

           if (Chess.chess[i][j] == Chess.chess[x][y]) { 

              r = i; 

              s = j; 

              break; 

           } 

       } 

       if (r != -2 && s != -2 && Chess.chess[x + 1][y + 1] != Chess.chess[i][j]) { 

           // 改变中间的子 

           paintChess2(x, y, i, j); 

           return new int[] { r, s }; 

       }

       else 

           return null;

    } 

 

    /* 斜左上方向     */

    public int[] xiezuo1(int x, int y) { 

       // 向上 

       int r = -2, s = -2; 

       int i, j; 

       for (i = x - 1, j = y - 1; i >= 0 && j >= 0; i--, j--) { 

           if (Chess.chess[i][j] == 0)

              break;

           if (Chess.chess[i][j] == Chess.chess[x][y]) { 

              r = i; 

              s = j; 

              break; 

           } 

       } 

       if (r != -2 && s != -2 && Chess.chess[x - 1][y - 1] != Chess.chess[i][j]) { 

           // 改变中间的子 

           paintChess3(x, y, i, j); 

           return new int[] { r, s }; 

       }

       else

           return null; 

    } 

 

    /* 斜左下方向    */

    public int[] xiezuo2(int x, int y) { 

       // 向下  

       int r = -2, s = -2; 

       int i, j; 

       for (i = x - 1, j = y + 1; i >= 0 && j < Chess.cols-1; i--, j++) { 

           if (Chess.chess[i][j] == 0)

              break;  

           if (Chess.chess[i][j] == Chess.chess[x][y]) { 

              r = i; 

              s = j; 

              break; 

           } 

       } 

       if (r != -2 && s != -2 && Chess.chess[x - 1][y + 1] != Chess.chess[i][j]) { 

           // 改变中间的子 

           paintChess4(x, y, i, j); 

           return new int[] { r, s }; 

       }

       else

           return null;

    } 

}

 

三、实验体会

这次实验内容比较复杂,做起来花了较长的时间。

前半部分是自己实验,学习敏捷开发与XP、编码标准、版本控制和重构。这些知识中比较难的是使用版本控制中的git功能,刚开始根据指导步骤实践时在vim中遇到困难,编写好代码后无法切回命令行界面,后来询问同学,了解到步骤是先按ESC键,再输入:wq,调试过后可以顺利进行后面的实验。其次,学习到最重要的思想---重构。重构包含各个方面,从简单的改变变量名称到较复杂的封装,使我感受到运用好重构可以大大提升我们编写代码的质量,而在接下来编写的小游戏中,我也通过运用这种思想优化了代码。

后半部分是编写一个java小游戏,由于自己的编程能力有限,因此我从网上克隆了一份关于黑白棋的代码。找到代码后,我和伙伴先是一起分析这个代码中语句的功能。然后,再进行重构,尽量使代码简化高效。然而,这并不是一件易事,也让我意识到自己的编程能力还需要很大的提升。

这次实验,我最大的收获是学会使用git功能和建立了重构的思想,这对我以后的java学习会有很大帮助。

 

 

附:

步骤

耗时

百分比

需求分析

0.5h

5%

设计

1.5h

15%

代码实现

5h

50%

测试

2h

20%

分析总结

1h

10%

20135115臧文君---实验3

标签:

原文地址:http://www.cnblogs.com/CatherineZang/p/4553430.html

(0)
(0)
   
举报
评论 一句话评论(0
登录后才能评论!
© 2014 mamicode.com 版权所有  联系我们:gaon5@hotmail.com
迷上了代码!