20135234mqy 实验三：敏捷开发与XP实践

　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　实     验    报     告

　　　　　　　　　　　　　　　　　　课程：Java 　　班级： 1352  　　 姓名：mqy   　　学号：20135234

　　　　　　　　　　　　　　　　　　成绩：             　　 指导教师：娄嘉鹏  　　　　　　  实验日期：2015.6.2

　　　　　　　　　　　　　　　　　　实验密级：         　　预习程度：        　　　　　　　 实验时间：17:00~23:00

　　　　　　　　　　　　　　　　　　仪器组次：34      　  必修/选修：选修    　　　　　　 实验序号：02

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

　　　　　　　　　　　　　　　　　　实验仪器：

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

实验内容：

1. XP基础

2. XP核心实践

3. 相关工具

实验步骤

（一）敏捷开发与XP

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

• RUP(Rational Unified Process)
• PSP(Personal Software Process )
• TSP(Team Software Process )
• Agile Process
• ……

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

敏捷开发包括很多模式：

其中，极限编程(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分钟。领航员要控制时间。
• 主动参与。任何一个任务都首先是两个人的责任，也是所有人的责任。没有“我的代码”、“你的代码”或“他/她的代码”，只有“我们的代码”。
• 只有水平上的差距，没有级别上的差异。两人结对，尽管可能大家的级别资历不同，但不管在分析、设计或编码上，双方都拥有平等的决策权利。

（四）版本控制

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

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

• 版本控制提供项目级的 undo（撤销） 功能： 没有什么事情是终结版本， 任何错误必须很容易回滚。 假设你在使用世界上最复杂的文字处理系统。 它具备了所有的能想到的功能，就是没有支持 DELETE（删除） 键。想象你打字的时候得多么的谨慎和缓慢吧， 特别是一篇超大的文档的快临近末尾的时候， 一个不小心就要重头再来（试想你选中所有的文字， 不小心按了 DELETE 键， 因为没有撤销功能，只好重新录入）。编辑文字和版本控制相同，任何时候都需要回滚，无论是一个小时， 一天， 还是一周， 这让你的团队工作自由快速的工作， 而且对于修正错误也非常自信。
• 版本控制允许多人在同一代码上工作， 只要遵守一定的控制原则就行。 再也不会发生诸如一个人覆盖了另一个人编辑的代码，导致那个人的修改无效这样的情况。
• 版本控制系统保存了过去所作的修改的历史记录。如果你遭遇到一些惊讶的代码，通过版本控制系统可以很容易找出是谁干的， 修改了什么， 修改的时间， 如果幸运的话，还能找出原因。
• 版本控制系统还支持在主线上开发的同时发布多个软件版本。在软件发布的时候也不需要整个团队的停止工作，不需要冻结代码。
• 版本控制也是项目级的时间机器，你可以选择任何一个时间， 精确地查看项目在当时的情况。 这对研究非常有用， 也是重现以前某个有问题的发布版本的基础。

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

实验楼上线我的代码库功能，为大家提供实验环境内置的公开的git服务。学习的课程会自动创建一个公开的代码仓库，命名为shiyanlou_cs[课程ID]，比如本课程的代码库命名shiyanlou_cs212,为启动实验时会在环境中自动执行git pull，获取课程仓库最新代码，存放在/home/shiyanlou/Code目录。git push操作需要手动完成，请务必在停止实验前push全部修改,否则代码就丢了。注意：

•代码库链接：http://git.shiyanlou.com/[您的专属用户名] •课程代码仓库的链接为：http://git.shiyanlou.com/[您的专属用户名]/shiyanlou_cs[课程ID] •实验环境中代码路径：/home/shiyanlou/Code/shiyanlou_cs[课程ID]

比如我的专属用户名是rocedu，则我的代码库链接为：http://git.shiyanlou.com/rocedu，我的《Java 程序设计》课程的代码仓库链接为：http://git.shiyanlou.com/rocedu/shiyanlou_cs212，该课程实验环境中代码路径为：/home/shiyanlou/Code/shiyanlou_cs212.

点击立即开通就可以开通我的代码库功能，进入页面完善信息即可，如果已经开通服务，请注意专属用户名必须是字母及数字的组合，建议包含学号信息。

使用方法如下：

1. 如果对Git不熟悉，推荐先学习Git课程
2. 开始实验时，如果您已经有了该课程的代码仓库则会自动同步（git pull）到实验环境中/home/shiyanlou/Code目录，如果还没有创建过则会自动创建并同步
3. 进入到实验环境中修改代码，完成后需要依次执行下述命令即可提交：

$ cd /home/shiyanlou/Code/shiyanlou_cs212
# 修改代码文件
# 添加修改文件
$ git add 所有修改的文件
# 提交到环境中本地代码仓库
$ git commit -m '本次修改的描述'
# push到git.shiyanlou.com，无需输入密码
$ git push

克隆其他用户代码仓库只需要知道对方的仓库链接：

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

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

创建HelloWorld目录

创建并编辑HelloWorld.java文件

上面测试代码没有问题了，就可以提交了：

修改HelloWorld.java

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

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

（五）重构

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

ABC类：

使用Eclipse中的重构功能来改名。修改方法是，用鼠标单击要改的名字，选择Eclipse中菜单中的Refactor->Rename...：

重构完的效果如下：

定义一个类Student

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

封装id和age两个成员变量

正常的重构可以使用Eclipse中的Extract Method...,

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

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

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

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

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

• 最单纯的Duplicated Code就是［同一个class内的两个方法含有相同表达式(expression)］。这时候你需要做的就是采用Extract Method提炼出重复的代码，然后让这两个地点都调用被提炼出来的那一段代码。
• 另一种常见情况就是[两个互为兄弟(sibling)的subclasses内含有相同表达式]。要避免这种情况，只需要对两个classes都使用Extract Method，然后再对被提炼出的代码使用Pull Up Method，将它推入superclass内。
• 如果代码之间只是类似，并非完全相同，那么就得运用Extract Method将相似部分和差异部分割开，构成单独一个方法。然后你可能发现或许可以运用Form Template Method获得一个Template Method设计模式。
• 如果有些方法以不同的算法做相同的事，你可以择定其中较清晰的一个，并使用Substitute Algorithm将其它方法的算法替换掉。
• 如果两个毫不相关的classes内出现Duplicaded Code，你应该考虑对其中一个使用Extract Class，将重复代码提炼到一个独立class中，然后在另一个class内使用这个新class。但是，重复代码所在的方法也可能的确只应该属于某个class，另一个class只能调用它，抑或这个方法可能属于第三个class，而另两个classes应该引用这第三个class。你必须决定这个方法放在哪儿最合适，并确保它被安置后就不会再在其它任何地方出现。

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

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

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

1. 从版本控制系统代码库中Check out code
2. 读懂代码（包括测试代码）
3. 发现bad smell
4. Refactoring
5. 运行所有的Unit Tests
6. 往代码库中Check in code

我们结合Git给出一个比较完整的例子。

（六）实践项目

题目  ：2048

一、题目简介

　　每次控制所有方块向同一个方向运动，两个相同数字的方块撞在一起之后合并成为他们的和，每次操作之后会在空白的方格处随机生成一个2或者4，最终得到一个“2048”的方块就算胜利了。

　　如果16个格子全部填满并且相邻的格子都不相同也就是无法移动的话，那么游戏结束。

二、实验结队分工

1：何伟钦：负责代码找寻与编写，控制键盘输入部分http://www.cnblogs.com/20135223heweiqin/
2：马启扬：负责代码修改与运行测试部分

三、需求分析

游戏操作需求：

1、可使用鼠标或↑、↓、→、←或W、X、A、D键进行操作；

2、Play按钮  重新开始游戏；

3、Undo按钮  取消本次操作，回到上一步。

2048游戏算法

1、游戏开始时随机的产生2个数值为2/4的方格，其中1个方格置于4个角中的一个位置，另一个方格随机的置于其它位置，其余方格值为0。

2、每次移动鼠标或按方向键后，逐行计算移动后的方格值。每行移动的算法是：先将所有  值为0的数移至行首。能后从行尾开始逐一和前一个数比较，如果相等则合并这2个格子。

3、每合并一次格子，将其值累计到游戏总分中。

4、一次移动结束后，在所有值为0的方格中随机的分配一个2/4的值。

5、所有方格值不为0且上下、左右相邻的方格都不相等，则游戏结束。

6、2出现的概率为90%，4出现的概率为为10%。

四、程序流程图

五、功能说明

(1) 实现可以显示2或者4两张数字的方块

(2) 实现各个方块的上下左右移动

(3) 实现方块间数字判断与相加

 

 .

六、具体代码

import javax.swing.*;
import java.awt.*;
import java.awt.event.*;
import java.io.*;
import java.util.*;
import javax.swing.border.*;

public class Test extends JApplet{
private static final int UP=0,DOWN=1,LEFT=2,RIGHT=3;
private static final int WID=150,SP=10;
private int scores=0;
private static JLabel scoreLabel;
private boolean change,CheckMode=false,gameOverFlag=false,successFlag=false;
private int[] label={2,4,8,16,32,64,128};
private Color[] clo={
new Color(200,200,200),new Color(228,228,160),new Color(214,163,92),
new Color(234,124,72),new Color(240,84,77),new Color(255,68,53),new Color(200,200,64)
};
private Map cmap=new HashMap();
public static RectObject[][] rset=new RectObject[4][4];
public RectObject[][] list=new RectObject[4][4];
private My2048Panel myp;
private LinkedList saveList=new LinkedList();
private JButton goBackButton;

KeyListener kl=new KeyListener(){
public void keyPressed(KeyEvent e){
saveTheStep();
goBackButton.setVisible(true);
if(gameOverFlag==true){
return;
}
if(!aDirAble()){
gameOver();
}
int key=e.getKeyCode();
switch(key){
case KeyEvent.VK_UP:
change=false;
moveUp(true);
if(change==true){
getARandomRect();
//saveTheStep();
}
break;
case KeyEvent.VK_DOWN:
change=false;
moveDown(true);
if(change==true){
getARandomRect();
//saveTheStep();
}
break;
case KeyEvent.VK_LEFT:
change=false;
moveLeft(true);
if(change==true){
getARandomRect();
//saveTheStep();
}
break;
case KeyEvent.VK_RIGHT:
change=false;
moveRight(true);
if(change==true){
getARandomRect();
//saveTheStep();
}
break;
}
//saveTheStep();
}
public void keyTyped(KeyEvent e){}
public void keyReleased(KeyEvent e){}
};

class RectObject{
private int value;
public RectObject(){
value=0;
}
public RectObject(RectObject obj){
value=obj.value;
}
public boolean equals(Object inobj){
RectObject obj=(RectObject)inobj;
if(obj.value==value){
return true;
}
return false;
}
}
class Point{
int x;
int y;
public Point(int i,int j){
x=i;
y=j;
}
}

class My2048Panel extends JPanel{
private int[] xindex={SP,2*SP+WID,3*SP+2*WID,4*SP+3*WID};
private int[] yindex={SP,2*SP+WID,3*SP+2*WID,4*SP+3*WID};

public void paintComponent(Graphics g){
//background
super.paintComponent(g);
for(int i=0;i<xindex.length;i++){
for(int j=0;j<yindex.length;j++){
g.setColor(Color.WHITE);
g.drawRoundRect(xindex[i], yindex[j], WID, WID, WID/5, WID/5);
g.setColor(new Color(197,183,129));
g.fillRoundRect(xindex[i], yindex[j], WID, WID, WID/5, WID/5);
}
}
//paint rectangle
for(int i=0;i<4;i++){
for(int j=0;j<4;j++){
if(rset[i][j]!=null){
g.setColor(Color.WHITE);
g.drawRoundRect(yindex[j], xindex[i], WID, WID, WID/5, WID/5);
if(rset[i][j].value<128){
g.setColor((Color)cmap.get(rset[i][j].value));
}else{
g.setColor((Color)cmap.get(128));
}
g.fillRoundRect(yindex[j], xindex[i], WID, WID, WID/5, WID/5);
g.setColor(Color.BLACK);

Font font=new Font("TimesRoman",Font.BOLD,50);
g.setFont(font);
FontMetrics fm=Toolkit.getDefaultToolkit().getFontMetrics(font);
int len=fm.stringWidth(""+rset[i][j].value);
int hg=fm.getHeight();
g.drawString(""+rset[i][j].value, yindex[j]+WID/2-len/2, xindex[i]+WID/2+hg/4);

if(rset[i][j].value==2048 && successFlag==false){
successFlag=true;
gameSuccess();
}
}
}
}
}
}

class GameOverPane extends JPanel{
public GameOverPane(int w,int h){
setSize(w,h);
//setOpaque(false);
}
public void paintComponent(Graphics g){
super.paintComponent(g);
Font font=new Font("TimesRoman",Font.BOLD,80);
g.setFont(font);
FontMetrics fm=Toolkit.getDefaultToolkit().getFontMetrics(font);
int width=fm.stringWidth("Game Over");
int height=fm.getHeight();
g.setColor(new Color(255,0,0));
g.drawString("Game Over!", getWidth()/2-width/2, getHeight()/2-height/2);
}
}

class SuccessPane extends JPanel{
public SuccessPane(int w,int h){
setSize(w,h);
//setOpaque(false);
}
public void paintComponent(Graphics g){
super.paintComponent(g);
Font font=new Font("TimesRoman",Font.BOLD,80);
g.setFont(font);
FontMetrics fm=Toolkit.getDefaultToolkit().getFontMetrics(font);
int width=fm.stringWidth("Success!");
int height=fm.getHeight();
g.setColor(new Color(255,0,0));
g.drawString("Success!", getWidth()/2-width/2, getHeight()/2-height/2);
}
}

class LOGO extends JPanel{
public LOGO(int w ,int h){
setSize(w,h);
}
public void paintComponent(Graphics g){
super.paintComponent(g);
Font font=new Font("TimesRoman",Font.BOLD,60);
g.setFont(font);
FontMetrics fm=Toolkit.getDefaultToolkit().getFontMetrics(font);
int width=fm.stringWidth("2048");
int height=fm.getHeight();
g.setColor(new Color(255,0,0));
g.drawString("2048", 20, getHeight()/2+20);
}
}

public class goBackListener implements ActionListener{
public void actionPerformed(ActionEvent e){
if(saveList.size()==0){
goBackButton.setVisible(false);
return;
}
ArrayList arr=(ArrayList)saveList.getLast();
scoreLabel.setText(""+arr.get(0));
for(int i=0;i<4;i++){
for(int j=0;j<4;j++){
int num=(int)arr.get(4*i+j+1);
if(num!=0){
rset[i][j]=new RectObject();
rset[i][j].value=num;
}else{
rset[i][j]=null;
}
}
}
saveList.removeLast();
repaint();
}
}

public class resetListener implements ActionListener{
public void actionPerformed(ActionEvent e){
refreshBest();
for(int i=0;i<4;i++){
for(int j=0;j<4;j++){
rset[i][j]=null;
}
}
scoreLabel.setText("0");
repaint();
getARandomRect();
getARandomRect();
}
}
//the applet init
public void init(){
Container cp=getContentPane();
cp.setLayout(null);
cp.setFocusable(true);
cp.addKeyListener(kl);

Font font=new Font("TimesNewman",Font.BOLD,30);
JLabel sl=new JLabel();
sl.setLayout(new GridLayout(2,1));
JLabel sllb=new JLabel("Scores");
sllb.setFont(font);
scoreLabel=new JLabel("0");
scoreLabel.setFont(font);
sl.add(sllb);
sl.add(scoreLabel);

int best=0;
try{
File file=new File("BestRecord");
if(file.exists()){
RandomAccessFile f=new RandomAccessFile(file,"rw");
best=f.readInt();
f.close();
}
}catch(FileNotFoundException e){
best=0;
e.printStackTrace();
}catch(IOException e){
best=0;
e.printStackTrace();
}
JLabel bsl=new JLabel();
bsl.setLayout(new GridLayout(2,1));
JLabel jl=new JLabel("Best");
jl.setFont(font);
JLabel jl1=new JLabel(""+best);
jl1.setFont(font);
bsl.add(jl);
bsl.add(jl1);

myp=new My2048Panel();
LOGO logo=new LOGO(0,0);

goBackButton=new JButton("UNDO");
goBackButton.setFont(font);
goBackButton.addActionListener(new goBackListener());
goBackButton.addKeyListener(kl);

JButton jb=new JButton("RESET");
jb.setFont(font);
jb.addActionListener(new resetListener());
jb.addKeyListener(kl);

sl.setBounds(500,20,200,80);
bsl.setBounds(300,20,200,80);
logo.setBounds(0, 0, 600, 100);
myp.setBounds(0,90,700,700);
goBackButton.setBounds(700,250,150,60);
jb.setBounds(700,450,150,60);

cp.add(sl);
cp.add(bsl);
cp.add(logo);
cp.add(myp);
cp.add(goBackButton);
cp.add(jb);

File f=new File("LASTRECORD");
if(f.exists()){
try{
RandomAccessFile file=new RandomAccessFile(f,"rw");
int num=file.readInt();
scoreLabel.setText(""+num);
for(int i=0;i<4;i++){
for(int j=0;j<4;j++){
num=file.readInt();
if(num!=0){
rset[i][j]=new RectObject();
rset[i][j].value=num;
}
}
}
file.close();
}catch(FileNotFoundException e){
e.printStackTrace();
}catch(IOException e){
e.printStackTrace();
}
}else{
getARandomRect();
getARandomRect();
}
}

public Test(){
//saveTheStep();
for(int i=0;i<7;i++){
cmap.put(label[i], clo[i]);
}
}
//moveLeft
public void moveLeft(boolean flag){
clearList(list);
for(int i=0;i<4;i++){
int k=0;
for(int j=0;j<4;j++){
if(rset[i][j]!=null){
list[i][k++]=new RectObject(rset[i][j]);
}
}
}
for(int i=0;i<4 && flag;i++){
for(int j=0;j<3;j++){
if(list[i][j]!=null && list[i][j+1]!=null && list[i][j].value==list[i][j+1].value){
list[i][j].value*=2;
if(CheckMode==false){
int sum=Integer.parseInt(scoreLabel.getText());
sum+=list[i][j].value;
scoreLabel.setText(""+sum);
}
list[i][j+1]=null;
j++;
}
}
}

if(isChange()){
if(CheckMode==false){
copySet(rset,list);
repaint();
moveLeft(false);
}
change=true;
}else{
repaint();
}
}
//moveRight
public void moveRight(boolean flag){
clearList(list);
for(int i=0;i<4;i++){
int k=3;
for(int j=3;j>-1;j--){
if(rset[i][j]!=null){
list[i][k--]=new RectObject(rset[i][j]);
}
}
}
for(int i=0;i<4 && flag;i++){
for(int j=3;j>0;j--){
if(list[i][j]!=null && list[i][j-1]!=null && list[i][j].value==list[i][j-1].value){
list[i][j].value*=2;
if(CheckMode==false){
int sum=Integer.parseInt(scoreLabel.getText());
sum+=list[i][j].value;
scoreLabel.setText(""+sum);
}
list[i][j-1]=null;
j--;
}
}
}

if(isChange()){
if(CheckMode==false){
copySet(rset,list);
repaint();
moveRight(false);
}
change=true;
}else{
repaint();
}
}
//moveup
public void moveUp(boolean flag){
clearList(list);
for(int j=0;j<4;j++){
int k=0;
for(int i=0;i<4;i++){
if(rset[i][j]!=null){
list[k++][j]=new RectObject(rset[i][j]);
}
}
}
for(int j=0;j<4 && flag;j++){
for(int i=0;i<3;i++){
if(list[i][j]!=null && list[i+1][j]!=null && list[i][j].value==list[i+1][j].value){
list[i][j].value*=2;
if(CheckMode==false){
int sum=Integer.parseInt(scoreLabel.getText());
sum+=list[i][j].value;
scoreLabel.setText(""+sum);
}
list[i+1][j]=null;
i++;
}
}
}

if(isChange()){
if(CheckMode==false){
copySet(rset,list);
repaint();
moveUp(false);
}
change=true;
}else{
repaint();
}
}
//movedown
public void moveDown(boolean flag){
clearList(list);
for(int j=0;j<4;j++){
int k=3;
for(int i=3;i>-1;i--){
if(rset[i][j]!=null){
list[k--][j]=new RectObject(rset[i][j]);
}
}
}
for(int j=0;j<4 && flag;j++){
for(int i=3;i>0;i--){
if(list[i][j]!=null && list[i-1][j]!=null && list[i][j].value==list[i-1][j].value){
list[i][j].value*=2;
if(CheckMode==false){
int sum=Integer.parseInt(scoreLabel.getText());
sum+=list[i][j].value;
scoreLabel.setText(""+sum);
}
list[i-1][j]=null;
i--;
}
}
}

if(isChange()){
if(CheckMode==false){
copySet(rset,list);
repaint();
moveDown(false);
}
change=true;
}else{
repaint();
}
}
//other functions
private void copySet(RectObject[][] dst, RectObject[][] src){
for(int i=0;i<4;i++){
for(int j=0;j<4;j++){
dst[i][j]=src[i][j];
}
}
}
//detect whether rset is different from list or not
private boolean isChange(){
for(int i=0;i<4;i++){
for(int j=0;j<4;j++){
if(rset[i][j]!=null && list[i][j]!=null && !rset[i][j].equals(list[i][j])){
return true;
}
if(rset[i][j]!=null && list[i][j]==null){
return true;
}
if(rset[i][j]==null && list[i][j]!=null){
return true;
}
}
}
return false;
}
private void clearList(RectObject[][] s){
for(int i=0;i<s.length;i++){
for(int j=0;j<s[i].length;j++){
s[i][j]=null;
}
}
}
//get a random rectangle
public void getARandomRect(){
ArrayList list=new ArrayList();
for(int i=0;i<4;i++){
for(int j=0;j<4;j++){
if(rset[i][j]==null){
list.add(new Point(i,j));
}
}
}
if(list.size()==0 && !aDirAble()){
gameOver();
return;
}
Random rand=new Random();
int index=rand.nextInt(list.size());
Point loc=(Point)list.get(index);
index=rand.nextInt(2);
rset[loc.x][loc.y]=new RectObject();
if(index==1){
rset[loc.x][loc.y].value=4;
}else{
rset[loc.x][loc.y].value=2;
}
}
//detect whether there are other steps or not
public boolean aDirAble(){
CheckMode=true;
change=false;
moveLeft(true);
moveRight(true);
moveDown(true);
moveUp(true);
CheckMode=false;
if(change==true){
return true;
}else{
return false;
}
}
public void gameOver(){
gameOverFlag=true;
final JPanel jl=new GameOverPane(myp.getWidth(),myp.getHeight());
jl.setBounds(0, 0, 700, 700);
JButton jb1=new JButton("Again");
Font font=new Font("TimesRoman",Font.BOLD,30);
jb1.setOpaque(false);
jb1.setFont(font);
JButton jb2=new JButton("Close");
jb2.setSize(jb1.getSize());
jb2.setOpaque(false);
jb2.setFont(font);
jb1.addActionListener(new ActionListener(){
public void actionPerformed(ActionEvent e){
scoreLabel.setText("0");
myp.remove(jl);
clearList(rset);
myp.validate();
getARandomRect();
getARandomRect();
repaint();
gameOverFlag=false;
refreshBest();
}
});
jb2.addActionListener(new ActionListener(){
public void actionPerformed(ActionEvent e){
refreshBest();
File f=new File("LASTRECORD");
if(f.exists()){
f.delete();
}
System.exit(0);
}
});
jl.add(jb1);
jl.add(jb2);
myp.add(jl);
jl.validate();
}
public void gameSuccess(){
JPanel jl=new SuccessPane(myp.getWidth(),myp.getHeight());
jl.setOpaque(false);
jl.setBounds(0, 0, 700, 700);
JButton jb1=new JButton("Continue");
Font font=new Font("TimesRoman",Font.BOLD,30);
jb1.setOpaque(false);
jb1.setFont(font);
JButton jb2=new JButton("Close");
jb2.setSize(jb1.getSize());
jb2.setOpaque(false);
jb2.setFont(font);
jb1.addActionListener(new ActionListener(){
public void actionPerformed(ActionEvent e){
myp.remove(jl);
myp.validate();
repaint();
}
});
jb2.addActionListener(new ActionListener(){
public void actionPerformed(ActionEvent e){
refreshBest();
System.exit(0);
}
});
jl.add(jb1);
jl.add(jb2);
myp.add(jl);
jl.validate();
}
public void saveTheStep(){
if(saveList.size()<20){
ArrayList arr=new ArrayList();
int score=Integer.parseInt(scoreLabel.getText());
arr.add(score);
for(int i=0;i<4;i++){
for(int j=0;j<4;j++){
if(rset[i][j]!=null){
arr.add(rset[i][j].value);
}else{
arr.add(0);
}
}
}
saveList.addLast(arr);
}else{
saveList.removeFirst();
saveTheStep();
}
}

public static String title(Object o){
String t=o.getClass().toString();
if(t.indexOf("class")!=-1){
t=t.substring(6);
}
return t;
}
public static void refreshBest(){
try {
int best=0;
File f=new File("BestRecord");
RandomAccessFile file;
if(f.exists()){
file=new RandomAccessFile(f,"rw");
best=file.readInt();
file.seek(0);
}else{
file=new RandomAccessFile(f,"rw");
}
//System.out.println("The Best score is "+best);
int cur=Integer.parseInt(scoreLabel.getText());
if(cur>best){
file.writeInt(cur);
}
file.close();
} catch (FileNotFoundException e1) {
e1.printStackTrace();
}catch(IOException e2){
e2.printStackTrace();
}
}
public static void saveRecord(){
try{
RandomAccessFile file=new RandomAccessFile(new File("LASTRECORD"),"rw");
int score=Integer.parseInt(scoreLabel.getText());
file.writeInt(score);
for(int i=0;i<4;i++){
for(int j=0;j<4;j++){
if(rset[i][j]!=null){
file.writeInt(rset[i][j].value);
}else{
file.writeInt(0);
}
}
}
}catch(FileNotFoundException e){
e.printStackTrace();
}catch(IOException e){
e.printStackTrace();
}
}
public static void run(JApplet applet,int width,int height){
JFrame frame=new JFrame(title(applet));
frame.addWindowListener(new WindowAdapter(){
public void windowClosing(WindowEvent e){
refreshBest();
saveRecord();
//System.out.println("The score is "+scoreLabel.getText());
}
});
frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
frame.getContentPane().add(applet);
frame.setSize(width,height);
applet.init();
applet.start();
frame.setVisible(true);
}
public static void main(String[] args){
run(new Test(), 900, 800);
}
}

七、运行结果截图：

八、心得体会

本次java时间项目我小组选择了“2048”小游戏，在试验过程中，使用到了GUI用户界面显示，并同时试写了测试代码。

编程过程中，出现了调用功能失误、类型不匹配代码、逻辑错误、运行结果不符合预期、操作指令混乱这五个问题，多亏了结伴编程，在编程的过程中即对错误的地方进行了修正，极大的减少了测试时间，提高了效率。

通过结对项目，我认识到了合作的重要性，紧密的合作能够提高我们的能力。

代码测试过程中出现很多错误，但经过互相的合作和探讨，加以改进，便可以成功运行。

统计的PSP(Personal Software Process)时间

步骤	耗时(min)	百分比
需求分析	1h	15%
设计	2h	35%
代码实现	2h	35%
测试	30	8%
分析总结	30	7%