---恢复内容开始---

JAVA实验报告三：敏捷开发与XP实践

20135231 何佳

实验内容

1. XP基础

2. XP核心实践

3. 相关工具

实验要求

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

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

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

实验仪器

名称	型号	数量
计算机	HP	1
实验楼		1

实验步骤

（一）敏捷开发与XP

软件工程是把系统的、有序的、可量化的方法应用到软件的开发、运营和维护上的过程。软件工程包括下列领域：软件需求分析、软件设计、软件构建、软件测试和软件维护。 人们在开发、运营、维护软件的过程中有很多技术、做法、习惯和思想体系。软件工程把这些相关的技术和过程统一到一个体系中，叫“软件开发流程”。软件开发流程的目的是为了提高软件开发、运营、维护的效率，并提高软件的质量、用户满意度、可靠性和软件的可维护性。 光有各种流程的思想是不够的，我们还要有一系列的工具来保证这些思想能够在实践中有效率地运作。软件开发很重要的一点不是看你能对多少理论讲的头头是道，还要看你对相关工具应用的如何，比如Java中单元测试要和JUnit的应用结合起来，建模要和Umbrello或StarUML的应用结合起来。编程学习是一个习而学的过程。 一个常见的公式是：软件工程=开发流程+工具 邹欣老师给出的两个公式:软件=程序+软件工程和软件企业=软件+商业模式

有：

l         RUP(Rational Unified Process)

l         PSP(Personal Software Process )

l         TSP(Team Software Process )

l         Agile Process

l         ……

敏捷开发（Agile Development）是一种以人为核心、迭代、循序渐进的开发方法。

敏捷开发（Agile Development）是一种以人为核心、迭代、循序渐进的开发方法。“敏捷流程”是一系列价值观和方法论的集合。从2001年开始，一些软件界的专家开始倡导“敏捷”的价值观和流程，他们肯定了流行做法的价值，但是强调敏捷的做法更能带来价值。

敏捷开发包括很多模式：

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

l        
XP是以开发符合客户需要的软件为目标而产生的一种方法论

l        
XP是一种以实践为基础的软件工程过程和思想

l        
XP认为代码质量的重要程度超出人们一般所认为的程度

l        
XP特别适合于小型的有责任心的、自觉自励的团队开发需求不确定或者迅速变化的软件

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

l        
沟通 ：XP认为项目成员之间的沟通是项目成功的关键，并把沟通看作项目中间协调与合作的主要推动因素。

l        
简单 ：XP假定未来不能可靠地预测，在现在考虑它从经济上是不明智的，所以不应该过多考虑未来的问题而是应该集中力量解决燃眉之急。

l        
反馈 ：XP认为系统本身及其代码是报告系统开发进度和状态的可靠依据。系统开发状态的反馈可以作为一种确定系统开发进度和决定系统下一步开发方向的手段。

l        
勇气：代表了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("20135231");

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

System.out.println(buffer.charAt(i));

}

}

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

l        
要体现各自的含义

l        
包、类、变量用名词

l        
方法名用动宾

l        
包名全部小写，如：io，awt

l        
类名第一个字母要大写，如：HelloWorldApp

l        
变量名第一个字母要小写，如：userName

l        
方法名第一个字母要小写：setName

l        
...

标识符名字应当直观且可以拼读，可望文知意，不必进行“解码”，一般采用英文单词或其组合，便于记忆和阅读，切忌使用汉语拼音来命名，用词要准确。

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

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

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

有一些公司比如Google公开了自己的编码标准，可以作为学习不错的参考，大家参考一下范飞龙老师写的代码规范&代码风格，有兴趣的可以尝试如何在Eclipse中实践Google Java Style(中文版)，也就是说如何做到“按一下快捷键Ctrl+Shift+F就可以让自己的代码符合Google Java
Style(中文版)的要求”，完成后单独写一篇Blog，有加分的。

（三）结对编程

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

l        
驾驶员（Driver）是控制键盘输入的人。

l       
领航员（Navigator）起到领航、提醒的作用。

重点是：

l        
驾驶员：写设计文档，进行编码和单元测试等XP开发流程。

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

l        
驾驶员和领航员不断轮换角色，不要连续工作超过一小时，每工作一小时休息15分钟。领航员要控制时间。

l        
主动参与。任何一个任务都首先是两个人的责任，也是所有人的责任。没有“我的代码”、“你的代码”或“他/她的代码”，只有“我们的代码”。

l        
只有水平上的差距，没有级别上的差异。两人结对，尽管可能大家的级别资历不同，但不管在分析、设计或编码上，双方都拥有平等的决策权利。。

（四）版本控制

XP的集体所有制意味着每个人都对所有的代码负责；这一点，反过来又意味着每个人都可以更改代码的任意部分。结对编程对这一实践贡献良多：借由在不同的结对中工作，所有的程序员都能看到完全的代码。集体所有制的一个主要优势是提升了开发程序的速度，因为一旦代码中出现错误，任何程序员都能修正它。
这意味着代码要放到一个大家都能方便获取的地方，我们叫代码仓库。这引出另外一个话题叫版本控制（Version Control）。

不论是对于团队还是个体，版本控制都提供了很多好处。

l        
版本控制提供项目级的 undo（撤销） 功能： 没有什么事情是终结版本， 任何错误必须很容易回滚。 假设你在使用世界上最复杂的文字处理系统。 它具备了所有的能想到的功能，就是没有支持 DELETE（删除） 键。想象你打字的时候得多么的谨慎和缓慢吧， 特别是一篇超大的文档的快临近末尾的时候， 一个不小心就要重头再来（试想你选中所有的文字，
不小心按了 DELETE 键， 因为没有撤销功能，只好重新录入）。编辑文字和版本控制相同，任何时候都需要回滚，无论是一个小时，
一天， 还是一周， 这让你的团队工作*快速的工作， 而且对于修正错误也非常自信。

l        
版本控制允许多人在同一代码上工作，
只要遵守一定的控制原则就行。 再也不会发生诸如一个人覆盖了另一个人编辑的代码，导致那个人的修改无效这样的情况。

l        
版本控制系统保存了过去所作的修改的历史记录。如果你遭遇到一些惊讶的代码，通过版本控制系统可以很容易找出是谁干的，
修改了什么， 修改的时间， 如果幸运的话，还能找出原因。

l        
版本控制系统还支持在主线上开发的同时发布多个软件版本。在软件发布的时候也不需要整个团队的停止工作，不需要冻结代码。

l        
版本控制也是项目级的时间机器，你可以选择任何一个时间，
精确地查看项目在当时的情况。 这对研究非常有用， 也是重现以前某个有问题的发布版本的基础。

l       
流行的版本控制工具有CVS，SVN，Git等,更多的可以参考这里。Git是Linus除了Linux操作系统外的另外一个重要发明。

克隆其他用户代码仓库只需要知道对方的仓库链接：$ git clone
http://git.shiyanlou.com/[对方的专属用户名]/[课程代码仓库名]

以HelloWorld的例子：

$ cd /home/shiyanlou/Code/shiyanlou_cs212

l        
# 修改代码文件

l        
# 添加修改文件

l        
$ git add 所有修改的文件

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

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

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

l        
$ git push

（五）重构

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

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

我们要修改软件，万变不离其宗，无非就是四种动机：

l        
增加新功能；

l        
原有功能有BUG；

l        
改善原有程序的结构；

l       
优化原有系统的性能 。

第一种和第二种动机，都是源于客户的功能需求，而第四种是源于客户的非功能需求。软件的外部质量，其衡量的标准就是客户对软件功能需求与非功能需求的满意度。它涉及到一个企业、一个软件的信誉度与生命力，因此为所有软件企业所高度重视。要提高软件内部质量，毫无疑问就是软件修改的第三个动机：改善原有程序的结构。它的价值是隐性的，并不体现在某一次或两次开发中，而是逐渐体现在日后长期维护的软件过程中。
高质量的软件，可以保证开发人员（即使是新手）能够轻易看懂软件代码，能够保证日后的每一次软件维护都可以轻易地完成（不论软件经历了多少次变更，维护了多少年），能够保证日后的每一次需求变更都能够轻易地进行（而不是伤筋动骨地大动）。要做到这几点其实并不容易，它需要我们持续不断地对系统内部质量进行优化与改进。这，就是系统重构的价值。
下面一个重要问题是哪些地方需要重构？有臭味道（Bad Smell）的代码。 什么是臭味道？想象一下你打开冰箱门，出来一股臭味道你就知道冰箱里有东西腐坏了，要清除了。代码一样有臭味道：

臭味行列中首当其冲的就是Duplicated Code(重复的代码)。如果你在一个以上的地点看到相同的程序结构，那么当可肯定：设法将它们合而为一，程序会变得更好。

l        
最单纯的Duplicated Code就是［同一个class内的两个方法含有相同表达式(expression)］。这时候你需要做的就是采用Extract Method提炼出重复的代码，然后让这两个地点都调用被提炼出来的那一段代码。

l        
另一种常见情况就是[两个互为兄弟(sibling)的subclasses内含有相同表达式]。要避免这种情况，只需要对两个classes都使用Extract Method，然后再对被提炼出的代码使用Pull Up Method，将它推入superclass内。

l        
如果代码之间只是类似，并非完全相同，那么就得运用Extract Method将相似部分和差异部分割开，构成单独一个方法。然后你可能发现或许可以运用Form Template Method获得一个Template Method设计模式。

l        
如果有些方法以不同的算法做相同的事，你可以择定其中较清晰的一个，并使用Substitute Algorithm将其它方法的算法替换掉。

l       
如果两个毫不相关的classes内出现Duplicaded Code，你应该考虑对其中一个使用Extract Class，将重复代码提炼到一个独立class中，然后在另一个class内使用这个新class。但是，重复代码所在的方法也可能的确只应该属于某个class，另一个class只能调用它，抑或这个方法可能属于第三个class，而另两个classes应该引用这第三个class。你必须决定这个方法放在哪儿最合适，并确保它被安置后就不会再在其它任何地方出现

其他Bad
Smell与相应的重构手法如下表所示：

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

一个完整的重构流程包括：

l        
从版本控制系统代码库中Check out code

l        
读懂代码（包括测试代码）

l        
发现bad smell

l        
Refactoring

l        
运行所有的Unit Tests

l       
往代码库中Check in code

（六）实践项目

1.实验内容：五子棋

2.实验结对分工

20135213林涵锦：负责查找、分析代码，测试运行是否可行。  http://www.cnblogs.com/20135213lhj/p/4553382.html

20135231何佳：负责修改代码、资料的整理工作，将java代码进行必要注释。

3.实验代码

建两个类

1.MainFrame类继承JFrame类

2.MainPanel类继承JPanel类实现接口MouseListener

package test. gobang;

import java.awt.BorderLayout;

import java.awt.Color;

import javax.swing.JFrame;

/**

* 五子棋

* @author
HJandLHJ

* @version 5213/5231

*/

public class MainFrame extends JFrame{

public static void main(String[] args) {

MainPanel panel = new MainPanel();

MainFrame frame = new MainFrame("五子棋");

frame.setSize(680,680);

anel.setBackground(Color.GRAY);

frame.add(panel,BorderLayout.CENTER);

panel.addMouseListener(panel);

frame.setVisible(true);

}

public MainFrame(){

super();

}

public MainFrame(String str){

super(str);

}

}

package game.gobang;

import java.awt.Color;

import java.awt.Graphics;

import java.awt.Panel;

import java.awt.event.MouseEvent;

import java.awt.event.MouseListener;

import javax.swing.JOptionPane;

public class MainPanel extends Panel implements
MouseListener{

private static final int COLUMN = 16;//列数

private static final int ROW = 16;//行数

private static final int GAP = 40;//间距

private static boolean isBlack = true;

private static int click_X;

private static int click_Y;

private char[][] allChess= new char[ROW][COLUMN];

public MainPanel(){

super();

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

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

llChess[i][j]='*';

}

}

}

public void paint(Graphics g){

for(int i=0;i<ROW;i++){//划横线

g.setColor(Color.BLACK);

g.drawLine(20, 20+i*GAP, 640-20, 20+i*GAP);

}

for(int i=0;i<COLUMN;i++){//划纵线

g.setColor(Color.BLACK);

g.drawLine(20+i*GAP, 20, 20+i*GAP, 640-20);

}

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

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

if(allChess[i][j]=='~'){

g.setColor(Color.WHITE);

g.fillOval(5+i*40, 5+j*40, 30, 30);

g.drawOval(5+i*40, 5+j*40, 30, 30);

}

if(allChess[i][j]=='!'){

g.setColor(Color.BLACK);

g.fillOval(5+i*40, 5+j*40, 30, 30);

g.drawOval(5+i*40, 5+j*40, 30, 30);

}

}

}

}

public boolean isWin(int x,int y,boolean isColor){//判断是否为5个相同的棋子，是返回true，否返回false

char ch=allChess[x][y];

/*  横向判断*/

int RLastX = x;

while(RLastX>=0 && allChess[RLastX][y]==ch){//横向判断是否到达5个相同的棋子

RLastX --;

}

int RNum = 0;//统计横向相同的棋子数

RLastX ++;

while(RLastX<allChess.length && allChess[RLastX][y]==ch){//横向判断是否到达5个相同的棋子

RNum ++;

RLastX ++;

}

/* 纵向判断   */

int LLastY = y;

while(LLastY>=0 && allChess[x][LLastY]==ch){//纵向判断是否到达5个相同的棋子

LLastY --;

}

int LNum = 0;//统计纵向相同的棋子数

LLastY ++;

while(LLastY<allChess[x].length && allChess[x][LLastY]==ch){//纵向判断是否到达5个相同的棋子

LLastY ++;

LNum ++;

}

/* 左下右上判断  */

int LDLastX = x;

int RULastY = y;

while(LDLastX>=0 && RULastY<allChess.length && allChess[LDLastX][RULastY]==ch){

LDLastX --;

RULastY ++;

}

int LDNum = 0;

LDLastX ++;

RULastY --;

while(LDLastX<allChess.length && RULastY>=0 && allChess[LDLastX][RULastY]==ch){

LDNum ++;

LDLastX ++;

RULastY --;

}

/* 左上右下判断  */

int RULastX = x;

int LDLastY = y;

while(RULastX>=0 && LDLastY>=0
&& allChess[RULastX][LDLastY]==ch){

RULastX --;

LDLastY --;

}

int RUNum = 0;

RULastX ++;

LDLastY ++;

while(RULastX>=0 && LDLastY<allChess.length && allChess[RULastX][LDLastY]==ch){

RULastX ++;

LDLastY ++;

RUNum ++;

}

if(RNum>=5||LNum>=5||RUNum>=5||LDNum>=5){

return true;

}

return false;

}

public void mouseClicked(MouseEvent e) {

// TODO Auto-generated
method stub

//System.out.println(e.getX());

//e.getY();

}

public void mousePressed(MouseEvent e) {//鼠标点击事件处理过程

// TODO Auto-generated
method stub

int click_x = e.getX();

int click_y = e.getY();

int chess_x = Math.round((float)(click_x-20)/GAP);

int chess_y = Math.round((float)(click_y-20)/GAP);

click_X = chess_x;

click_Y = chess_y;

if(isBlack==true&&allChess[chess_x][chess_y]=='*'){

allChess[chess_x][chess_y] = '!';

isBlack = false;

}

if(isBlack==false&&allChess[chess_x][chess_y]=='*'){

allChess[chess_x][chess_y] = '~';

isBlack = true;

}

System.out.println(e.getX());

System.out.println(e.getY());

repaint();

for(int j=0;j<16;j++){

for(int i=0;i<16;i++){

System.out.print(allChess[i][j]+" ");

}

System.out.println();

}

System.out.println();

if(isWin(chess_x,chess_y,isBlack)){

System.out.println("你赢了");

}

if(isWin(chess_x,chess_y,isBlack)){

if(isBlack){

JOptionPane.showMessageDialog(null,"白子赢了");

}else{

JOptionPane.showMessageDialog(null,"黑子赢了");

}

System.exit(0);

}

}

@Override

public void mouseReleased(MouseEvent e) {

// TODO Auto-generated
method stub

}

@Override

public void mouseEntered(MouseEvent e) {

// TODO Auto-generated
method stub

}

@Override

public void mouseExited(MouseEvent e) {

// TODO Auto-generated
method stub

}

public void setAllChess(char[][] allChess) {

this.allChess = allChess;

}

public char[][] getAllChess() {

return allChess;

}

}

（七）遇到问题与解决方法：

1.实验楼实验所给的的步骤有省略，开局运行与图片不一样。

　　　　解决：仔细查看文字，先创建git仓库，再重新做一遍，运行结果一样了。

2.在代码编辑完成后，最开始不会对其进行编译。

　　　　解决：按esc，然后输入“：wp”进行编译。然后可以按图片进行下一步javac以及java的操作。

3.由于网络信号不好，虚拟机运行非常慢，以致这次实验非常耗费时间。

　　　　解决：实验4在虚拟机写，实验练习5直接用自己的电脑运行。

4.在逻辑代码里直接做写交互代码导致代码十分复杂。

解决：创建两个类，一个class是处理界面交互相关的，一个class专门写和界面交互无关的代码，简单了许多。

(八)感想总结

软件的独立单元将在与程序的其他部分相隔离的情况下进行测试，可以查找错误、写出高质量的代码、提高编程水平。也可以使代码可以放心修改和重构、使程序员从调用者而不是实现者的角度设计软件模块。通过和小组成员的合作拓宽思路，找到自己思维的盲点，想到解决的办法。同时在与小组成员的沟通中可以学习到更多。

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