实验三 敏捷开发与XP实践 实验报告 20135232王玥

一、实验内容

1. XP基础

2. XP核心实践

3. 相关工具

二、实验要求

1.没有Linux基础的同学建议先学习《Linux基础入门（新版）》《Vim编辑器》 课程

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

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

三、实验步骤

（一）敏捷开发与XP

敏捷开发包括很多模式：

其中，极限编程(eXtreme Programming，XP)是是一种全新而快捷的软件开发方法。XP团队使用现场客户、特殊计划方法和持续测试来提供快速的反馈和全面的交流：

• XP是以开发符合客户需要的软件为目标而产生的一种方法论
• XP是一种以实践为基础的软件工程过程和思想
• XP认为代码质量的重要程度超出人们一般所认为的程度
• XP特别适合于小型的有责任心的、自觉自励的团队开发需求不确定或者迅速变化的软件

XP软件开发是什么样的通过 XP准则来表达：

• 沟通 ：XP认为项目成员之间的沟通是项目成功的关键，并把沟通看作项目中间协调与合作的主要推动因素。
• 简单 ：XP假定未来不能可靠地预测，在现在考虑它从经济上是不明智的，所以不应该过多考虑未来的问题而是应该集中力量解决燃眉之急。
• 反馈 ：XP认为系统本身及其代码是报告系统开发进度和状态的可靠依据。系统开发状态的反馈可以作为一种确定系统开发进度和决定系统下一步开发方向的手段。
• 勇气：代表了XP认为人是软件开发中最重要的一个方面的观点。在一个软件产品的开发中人的参与贯穿其整个生命周期，是人的勇气来排除困境，让团队把局部的最优抛之脑后，达到更重大的目标。表明了XP对“人让项目取得成功”的基本信任态度。

一项实践在XP环境中成功使用的依据通过XP的法则呈现，包括：快速反馈、假设简单性、递增更改、提倡更改、优质工作。

XP软件开发的基石是XP的活动，包括：编码、测试、倾听、设计。

项目成员用户成功执行XP活动的技术通过XP实践来呈现，包括编程、团队、过程相关的12条实践：

我们关注其中的编码标准，结对编程，代码集体所有，测试，重构等实践。上次实验已经讲过TDD，通过学习这些实践，可以形成以测试为核心的开发流程：

敏捷可以作为一种做事的方式，掌握好的在以后的工作中也会受益无穷。

（二）编码标准

编程标准使代码更容易阅读和理解，甚至可以保证其中的错误更少。编程标准包含：具有说明性的名字、清晰的表达式、直截了当的控制流、可读的代码和注释，以及在追求这些内容时一致地使用某些规则和惯用法的重要性。

编码标准中的版式就是一个很好的例子，版式虽然不会影响程序的功能，但会影响可读性。程序的版式追求清晰、美观，是程序风格的重要因素。

我们常见的是这样的代码:

public class CodeStandard {
public static void main(String [] args){
StringBuffer buffer = new StringBuffer();
buffer.append('S');
buffer.append("tringBuffer");
System.out.println(buffer.charAt(1));
System.out.println(buffer.capacity());
System.out.println(buffer.indexOf("tring"));
System.out.println("buffer = " + buffer.toString());
if(buffer.capacity()<20)
buffer.append("1234567");
for(int i=0; i<buffer.length();i++)
System.out.println(buffer.charAt(i));
}
}


程序没有最基本的缩进，让人读起来很费劲，这个问题在Eclipse中比较容易解决，我们单击Eclipse菜单中的source->Format 或用快捷键Ctrl+Shift+F就可以按Eclipse规定的规范缩进，效果如下：

怎么样？代码好读多了吧？有层次感了吧？如果能根据代码逻辑加入一些空行就更好了，如下图：

代码标准中很重要的一项是如何给包、类、变量、方法等标识符命名，能很好的命名可以让自己的代码立马上升一个档次。Java中的一般的命名规则有：

• 要体现各自的含义
• 包、类、变量用名词
• 方法名用动宾
• 包名全部小写，如：io，awt
• 类名第一个字母要大写，如：HelloWorldApp
• 变量名第一个字母要小写，如：userName
• 方法名第一个字母要小写：setName
• ...

标识符名字应当直观且可以拼读，可望文知意，不必进行“解码”，一般采用英文单词或其组合，便于记忆和阅读，切忌使用汉语拼音来命名，用词要准确例如“当前值”应该起名currentValue，写成nowValue就不准确了，但还凑合，写成dqz(dang qian zhi 首字母)就是笑话了。

标识符的长度“min-length && max-information”的原则，比如：maxVal 比maxValueUntilOverflow要好些，可以通过去元音法把变量名变短，如returnValue->rtnVal ，message->msg；一般全局变量用具有说明性的名字，局部变量用短名字：单字符的名字，常见的如i，j，k等用作局部变量。

其他的可以参考邹欣老师写的代码规范与代码复审.

关于代码标准，可以遵循以下原则：

（三）结对编程

结对编程是XP中的重要实践。在结对编程模式下，一对程序员肩并肩、平等地、互补地进行开发工作。他们并排坐在一台电脑前，面对同一个显示器，使用同一个键盘、同一个鼠标一起工作。他们一起分析，一起设计，一起写测试用例，一起编码，一起做单元测试，一起做集成测试，一起写文档等。 结对编程中有两个角色：

• 驾驶员（Driver）是控制键盘输入的人。
• 领航员（Navigator）起到领航、提醒的作用。

如何结对编程，为何要结对编程，大家参考一下结对编程和两人合作 ，重点是：

• 驾驶员：写设计文档，进行编码和单元测试等XP开发流程。
• 领航员：审阅驾驶员的文档、驾驶员对编码等开发流程的执行；考虑单元测试的覆盖率；思考是否需要和如何重构；帮助驾驶员解决具体的技术问题。
• 驾驶员和领航员不断轮换角色，不要连续工作超过一小时，每工作一小时休息15分钟。领航员要控制时间。
• 主动参与。任何一个任务都首先是两个人的责任，也是所有人的责任。没有“我的代码”、“你的代码”或“他/她的代码”，只有“我们的代码”。
• 只有水平上的差距，没有级别上的差异。两人结对，尽管可能大家的级别资历不同，但不管在分析、设计或编码上，双方都拥有平等的决策权利。

团队精神是好多地方都强调的一个精神，最小的团队就是一对一的二人团队了，培养团队精神从结对编程开始吧。社会生活中人与人相处最重要的是诚信，有同理心，互利。结对编程中大家会出现分歧，如何更有效地合作要做到对事不对人，掌握这些是可以终生受益的，如何影响小伙伴，大家参考一下两人合作:要会做汉堡包。

（四）版本控制

我们给一个HelloWorld的例子： 首先进入Code目录，你会发现有了shiyanlou_cs212目录，进入shiyanlou_cs212，如下图所示创建图所示：

创建并编辑HelloWorld.java文件，如下图所示：

注意一点，往代码库提交的代码一定编译、运行、测试都没有问题的代码，我们上面测试代码没有问题了，就可以提交了：

可以先用git status查看一下代码状态，显示有未跟踪的代码，并建议用git add <file>...添加，我们使用git add HelloWorld.* 把要提交的文件的信息添加到索引库中。当我们使用git commit时，git将依据索引库中的内容来进行文件的提交。这只是在本地操作，关闭实验环境，会删除代码的，如果想把代码保存到远程托管服务器中，需要使用git push，实验完成前，一定不要忘了使用git push，否则就是相当于你在Word中编辑了半天文件最后却没有保存。 我们可以修改HelloWorld.java，如下图所示：

编译、运行、测试没有问题后进行提交，这儿使用的是git commit -a：

，

我们可以通过git log查看代码提交记录：

谁在什么时候写了什么代码非常清楚。例子到此结束，有个问题是HelloWorld.class是不应该保存在代码库中的，我们只要有HelloWorld.java就行了，这怎么办？通过搜索引擎解决一下。

（五）重构

我们先看看重构的概念:

重构(Refactor)，就是在不改变软件外部行为的基础上，改变软件内部的结构，使其更加易于阅读、易于维护和易于变更 。

重构中一个非常关键的前提就是“不改变软件外部行为”，它保证了我们在重构原有系统的同时，不会为原系统带来新的BUG，以确保重构的安全。如何保证不改变软件外部行为？重构后的代码要能通过单元测试。如何使其更加易于阅读、易于维护和易于变更？设计模式给出了重构的目标。

例如这有个ABC类：

这个类，类名，方法名和方法的参数名都有问题，没有注释的话是无法理解代码的。我们可以使用Eclipse中的重构功能来改名。修改方法是，用鼠标单击要改的名字，选择Eclipse中菜单中的Refactor->Rename...：

重构完的效果如下：

功能不变，代码水平立马上了一个档次，体会到命名的威力了吧？

学过C语言的学生学Java时常犯的毛病是不会封装，该用类的地方都用了结构体。比如要定义一个类Student,会出现这样的代码：

Eclipse中菜单中的Refactor->Encapsulate Field...,如下图：

化：

同样可以封装id和age两个成员变量，结果如下：

上面第34，35行还是有问题的，每次打印学生信息都这么写代码违反了DRY原则，造成代码重复，正常的重构可以使用Eclipse中的Extract Method...,如下图：

由于Java中所有的类都有个专门的toString方法，我们使用Eclipse中Source->Generate toString()... 给Student类产生一个toString方法,如下图：

修改main的代码，结果如下：

（六）实践项目

结对同学网址：http://www.cnblogs.com/20135228guoyao/

实验代码：

package snake;

public enum Dir {
L, U, R, D
}

package snake;

import java.awt.*;
import java.util.Random;

public class Egg {
int row, col; // 位置
int w = Yard.BLOCK_SIZE;
int h = Yard.BLOCK_SIZE; // 宽，高
public static Random r = new Random();
private Color color = Color.RED;

public Egg(int x, int y) {
this.row = x;
this.col = y;
}

// 随机产生一个蛋的出现位置

public Egg() {
this(r.nextInt(Yard.ROWS - 3) + 3, r.nextInt(Yard.COLS));
} // Yard.ROWS-3)+3保证随机产生的蛋不产生在蓝边框里面

// 吃掉以后，重新产生一个蛋
public void reAppear() {
this.row = r.nextInt(Yard.ROWS - 3) + 3;
this.col = r.nextInt(Yard.COLS);
}

// 用于检测有没有碰撞
public Rectangle getRect() {
return new Rectangle(Yard.BLOCK_SIZE * col, Yard.BLOCK_SIZE * row, w, h);

}

public void draw(Graphics g) {
Color c = g.getColor();
g.setColor(color);
g.fillOval(Yard.BLOCK_SIZE * col, Yard.BLOCK_SIZE * row, w, h);
g.setColor(c);
if (color == Color.RED)
color = Color.BLACK;
else
color = Color.RED;
}

}

package snake;

import java.awt.*;
import java.awt.event.KeyEvent;

public class Snake {
private Node head = null;
private Node tail = null;
private int size = 0;

// 创建一个蛇的单个身体
private Node n = new Node(10, 10, Dir.L);

// 定义一个院子，
public Yard y;

public Snake(Yard y) {
head = n;
tail = n;
size = 1;
this.y = y;

}

// 蛇增长的时候，从尾部增长
/*
* public void addToTail() { Node node = null; switch(tail.dir) { case L:
* node = new Node(tail.row,tail.col+1,tail.dir); break; case U: node = new
* Node(tail.row+1,tail.col,tail.dir); break; case R: node = new
* Node(tail.row,tail.col-1,tail.dir); break; case D: node = new
* Node(tail.row-1,tail.col,tail.dir); break;
*
* } tail.next = node; node.prev =tail; tail = node; size++; }
*/

public void addToTail() {
Node node = null;
switch (tail.dir) {
case L:
node = new Node(tail.row, tail.col + 1, tail.dir);
break;
case U:
node = new Node(tail.row + 1, tail.col, tail.dir);
break;
case R:
node = new Node(tail.row, tail.col - 1, tail.dir);
break;
case D:
node = new Node(tail.row - 1, tail.col, tail.dir);
break;
}
tail.next = node;
node.prev = tail;
tail = node;
size++;
}

// 蛇增长的时候，从头部开始增长
/*
* public void addToHead() { Node node = null; switch(head.dir) { case L:
* node = new Node(head.row,head.col-1,head.dir); break; case U: node = new
* Node(head.row-1,head.col,head.dir); break; case R: node = new
* Node(head.row,head.col+1,head.dir); break; case D: node = new
* Node(head.row+1,head.col,head.dir); break;
*
* } node.next = head; head.prev = node; head = node; size++; }
*/

public void addToHead() {
Node node = null;
switch (head.dir) {
case L:
node = new Node(head.row, head.col - 1, head.dir);
break;
case U:
node = new Node(head.row - 1, head.col, head.dir);
break;
case R:
node = new Node(head.row, head.col + 1, head.dir);
break;
case D:
node = new Node(head.row + 1, head.col, head.dir);
break;
}
node.next = head;
head.prev = node;
head = node;
size++;
}

// 对整条蛇都重绘一下
public void draw(Graphics g) {
if (size <= 0)
return;

move();
for (Node n = head; n != null; n = n.next) {
n.draw(g);
}

// 将蛇画出来了后，将蛇移动
// move();
}

// 蛇的移动过程：在蛇的head前面添加一个身子，然后将后面的尾巴删除掉
private void move() {
addToHead();
deleteFromTail();

checkDead(); // 判断蛇有没有死亡
}

private void checkDead() {
if (head.row < 2 || head.col < 0 || head.row > Yard.ROWS
|| head.col > Yard.COLS) {
y.stop();
} // 如果撞到墙了，则死亡

for (Node n = head.next; n != null; n = n.next) {
if (head.row == n.row && head.col == n.col)
y.stop(); // 撞到自己身上了，则死亡
}

}

private void deleteFromTail() {
if (size == 0)
return;

tail = tail.prev; // 1.现在的蛇尾变为原来蛇尾巴前面的那个节点
tail.next = null; // 2.现在的蛇尾的下一个节点为空

}

// 定义一个类，以描述蛇身体的单个节点
private class Node {
public int w = Yard.BLOCK_SIZE; // 一节身体的大小
public int h = Yard.BLOCK_SIZE;
public int row, col; // 控制节点的坐标
public Dir dir = Dir.L;
Node next = null; // 指向下一个蛇身节点的指针
Node prev = null; // 指向前一个蛇身节点的指针

// 构造函数，用于初始化成员变量
Node(int row, int col, Dir dir) {
this.row = row;
this.col = col;
this.dir = dir;
}

// 画出单个节点
void draw(Graphics g) {
Color c = g.getColor();
g.setColor(Color.BLACK);
g.fillRect(Yard.BLOCK_SIZE * col, Yard.BLOCK_SIZE * row, w, h);

g.setColor(c);
}
}

public void eat(Egg e) {
if (this.getRect().intersects(e.getRect())) {
e.reAppear();
this.addToHead();
y.setScore(y.getScore() + 5); // 吃了一个蛋就加5分
}
}

public Rectangle getRect() {
return new Rectangle(Yard.BLOCK_SIZE * head.col, Yard.BLOCK_SIZE
* head.row, head.w, head.h);

}

// 当键盘点击了后，改变蛇的方向，即改变蛇头的方向
public void KeyPressed(KeyEvent e) {
int key = e.getKeyCode();
switch (key) {
case KeyEvent.VK_LEFT: // 向左走，如过原来的方向是向右的话，则使用左键就没有效果，也就是
// 原来的方向是左，上，下，都可以使方向变为左，唯独右不能使方向
if (head.dir != Dir.R) // 变为左
head.dir = Dir.L;
break;
case KeyEvent.VK_UP:
if (head.dir != Dir.D)
head.dir = Dir.U;
break;
case KeyEvent.VK_RIGHT:
if (head.dir != Dir.L)
head.dir = Dir.R;
break;
case KeyEvent.VK_DOWN:
if (head.dir != Dir.U)
head.dir = Dir.D;
break;

}

}

}

package snake;

import java.awt.Color;
import java.awt.Frame;
import java.awt.Graphics;
import java.awt.Image;
import java.awt.event.KeyEvent;
import java.awt.event.WindowAdapter;
import java.awt.event.WindowEvent;
import java.awt.event.KeyAdapter;
import java.awt.*;

public class Yard extends Frame {

PaintThread paintThread = new PaintThread();

public static final int ROWS = 30; // 院子的大小
public static final int COLS = 30;
public static final int BLOCK_SIZE = 15; // 一个方块的长和宽都为BLOCK_SIZE

public int score = 0;

// 双缓冲，消除闪烁
Image offScreenImage = null;

// flag用于判断是否重画，当蛇撞到自己或者撞到墙就停止重画，游戏就结束，画面停止，不再重画
public boolean flag = true;

// 定义一条小蛇,系统会自动调用下面那个重载的paint()方法，将蛇绘出来
Snake s = new Snake(this);
Egg e = new Egg(); // 定义一个蛋

public void Launch() {
this.setLocation(100, 100); // Yard的位子，左上角的那个点
this.setSize(COLS * BLOCK_SIZE, ROWS * BLOCK_SIZE);// 院子大小

this.addWindowListener(new WindowAdapter() {

public void windowClosing(WindowEvent e) {
setVisible(false);
System.exit(0);
}

});

this.setVisible(true);// 显示出院子

this.addKeyListener(new KeyMonitor());
// 让蛇动起来的线程，启动起来
new Thread(paintThread).start();

}

public void stop() {
flag = false;

}

public static void main(String[] args) {
new Yard().Launch();

}

// 重写Frame类的paint()方法，以显示院子里面的格子
public void paint(Graphics g) {
Color c = g.getColor();
g.setColor(Color.GRAY);
g.fillRect(0, 0, ROWS * BLOCK_SIZE, COLS * BLOCK_SIZE); // 指定的区域填充灰色的矩形
g.setColor(Color.DARK_GRAY);

for (int i = 0; i < ROWS; i++) {
g.drawLine(0, BLOCK_SIZE * i, BLOCK_SIZE * COLS, BLOCK_SIZE * i);
g.drawLine(BLOCK_SIZE * i, 0, BLOCK_SIZE * i, BLOCK_SIZE * ROWS);
}

g.setColor(Color.CYAN);
g.drawString("您的分数：" + score, 10, 60);

// 如果死掉了，输出game over

g.setColor(c);
//
s.draw(g);
s.eat(e);
e.draw(g);

if (flag == false) {
g.setColor(Color.CYAN);
g.setFont(new Font("华文彩云", Font.BOLD, 50));
g.drawString("您的游戏已经结束", 10, 250);
}

}

// 消除闪烁，重载update()
public void update(Graphics g) {
if (offScreenImage == null) {
offScreenImage = this.createImage(COLS * BLOCK_SIZE, ROWS
* BLOCK_SIZE);
}
Graphics gOff = offScreenImage.getGraphics();
paint(gOff);
g.drawImage(offScreenImage, 0, 0, null);

}

// 让蛇动起来，起一个线程
private class PaintThread implements Runnable {

public void run() {
while (true) {
if (flag) { // 如果蛇没有死，就重画，否则不重画
repaint(); // 会调用上面过重载过的paint()
}
try {
Thread.sleep(250); // 休眠50毫秒
} catch (InterruptedException e) {
e.printStackTrace();
}
}

}

}

// 让蛇动起来，前面已经启动了一个线程，现在创建一个监听
private class KeyMonitor extends KeyAdapter {

// @Override
public void keyPressed(KeyEvent e) {
s.KeyPressed(e);
}

}

public int getScore() {
return score;
}

public void setScore(int score) {
this.score = score;
}
}

伪代码：

1.设计一个行为30，列为50，由格子构成的院子

2.定义一条蛇和一个蛋，蛇吃掉一个蛋后则在院内任意地方随机产生一个蛋。

3.蛇吃掉一个蛋则加5分

4.若碰到蛋则蛇的身体变长一格，游戏继续，启动游戏后若蛇碰到边界或是自己的身体则游戏结束。

四、实验代码截图

五、实验体会

本次实验难度系数较大，根据实验指导书，前面的几项任务都不太复杂，根据指导可以很容易实现，并且让我们了解了如何快速规范化代码的格式和重构的应用方法。但是对于最后的游戏设计这个环节而言，我和我的搭档意识到平时所学的java知识不足以完美地完成本次实验，因此我借鉴了网上与贪吃蛇游戏相关的代码，认真研读、理解代码内容，并细心调试代码，最终完成了本次实验中难度最大的部分。在研究代码的过程中，我对git的应用理解加深，熟练掌握这个工具后，对我们日后的编程学习大有裨益。同时，我们需要继续深入学习有关java开发的知识，不能仅仅满足于书本，也不能仅仅满足于看懂代码，更重要的是亲手编写代码，在亲身实践中收获更多。

七、时间

步骤	耗时	百分比
需求分析	2h	10%
设计	4h	20%
代码实现	8h	40%
测试	3h	15%
分析总结	3h