北京电子科技学院（BESTI）

实     验    报     告

课程：Java程序设计   班级：1353       姓名：李海空  学号：20135329

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

实验密级：         预习程度：             实验时间：

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

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

实验目的与要求：

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

实验仪器：

名称	型号	数量
Pc		1

实验步骤

（一）敏捷开发与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，通过学习这些实践，可以形成以测试为核心的开发流程：

（二）编码标准

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

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

程序没有最基本的缩进，让人读起来很费劲，这个问题在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操作系统外的另外一个重要发明。

（五）重构

我们先看看重构的概念:

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

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

例子如下：

• 增加新功能；
• 原有功能有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。你必须决定这个方法放在哪儿最合适，并确保它被安置后就不会再在其它任何地方出现

（六）实践项目

1.分工

团队由两名成员组成，详细分工为：

20135329李海空：负责前期代码的整理工作，将java代码进行必要注释和实验报告整理。

20135327郭皓：负责代码编写和调试；进行后期实验报告整理。

结对对象blog:郭皓  ：http://www.cnblogs.com/20135327leme/

2.研读要求与自我学习（20135323）

TDD(Test Driven Development, 测试驱动开发)，

TDD的一般步骤如下：

• 明确当前要完成的功能，记录成一个测试列表
• 快速完成编写针对此功能的测试用例
• 测试代码编译不通过（没产品代码呢）
• 编写产品代码
• 测试通过
• 对代码进行重构，并保证测试通过（重构下次实验练习）
• 循环完成所有功能的开发

测试类具体操作：把鼠标放到项目名上，单击右键，在弹出的菜单中选定New->Source Folder新建一个测试目录test；把鼠标放到test目录上，单击右键，在弹出的菜单中选定New->JUnit Test Case新建一个测试用例类

实验要求要点为：程序要有GUI界面，参考用户界面和用户体验；记录TDD和重构的过程，测试代码不要少于业务代码

实验内容：游戏2048

实验思路：

1.首先要构造一个4*4的框架，作为游戏的界面

2.检查是否有空的方格

3.建立随机插入2或4的方法函数

4.设计up,down,right,left模块

·使用扫描法 以UpBlock为例：

public int Find(int i,int j,int a,int b) //对空模块进行赋值
{ 
　　while(i<b&&i>=a) 
　　{ 
　　　　if(block[i].getValue()!=0) 
　　　　　{ 
　　　　　　return i; 
　　　　　} 
　　　　　　i=i+j; 
　　} 
return -1; 
} 
public void upBlock() 
{ 
　　int i=0,j=0;int t=0;int valueJ=0;int valueI=0;int index=0; 
　　for(i=0;i<4;i++)//行扫描 
　　　　{ 
　　　　　　index=i; 
　　　　　　for(j=i+4;j<16;j+=4) //列扫描
　　　　{ 
　　valueJ=0; valueI=0; 
　　if(block[index].getValue()==0) 
　　{ 
　　　　t=Find(index,4,0,16); 
　　　　if(t!=-1) //为每一列的数向上叠加
　　　　　　{ 
　　　　　　　　block[index].setValue(block[t].getValue()); 
　　　　　　　　block[t].setValue(0); 
　　　　　　} 
　　　　else
　　　　{ 
　　　　　　break; 
　　　　} 
　　} 
　　valueI=block[index].getValue(); 
　　if(block[j].getValue()==0) 
　　{ 
　　　　t=Find(j,4,0,16); 
　　　　if(t!=-1) 
　　　　　{ 
　　　　　　block[j].setValue(block[t].getValue()); 
　　　　　　block[t].setValue(0); 
　　　　　} 
　　　　else
　　　　　{ 
　　　　　　break; 
　　　　　　} 
　　} 
　　valueJ=block[j].getValue(); 
　　if(valueI==valueJ&&valueI!=0&&valueJ!=0) 
　　{ 
　　　　block[index].setValue(valueI+valueJ); //相同相加
　　　　block[j].setValue(0); 
　　　　numFlag = true; 
　　} 
　　index=j; 
　　}

　　} 
}

5.为不同的模块数设计不同的颜色

具体代码：

主函数：My2048

import java.awt.*; 
import javax.swing.*; 
public class My2048 extends JFrame 
{ 
public My2048()//构造函数 
{ 
setTitle("娱乐型2048");//设置标题 
setSize(400, 400);//设定窗口大小 
setLocation(500, 200);//设定窗口起始位置 
setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); 
getContentPane().setLayout(new GridLayout(4, 4, 5, 5));//设定布局方式为GridLayout型 
new Operation(this); 
this.setVisible(true);//设为可视 
}

public static void main(String args[]) //程序入口点 
{ 
try
{ 
UIManager.setLookAndFeel("org.jvnet.substance.skin.SubstanceRavenGraphiteLookAndFeel");//设定UI 
} //接受抛出的异常 
catch (ClassNotFoundException | InstantiationException| IllegalAccessException | UnsupportedLookAndFeelException e) 
{ 
e.printStackTrace(); 
} 
JFrame.setDefaultLookAndFeelDecorated(true);//设定Frame的缺省外观 
new My2048(); 
}

}

具体操作函数Operation:

import java.awt.event.*; 
import javax.swing.*; 
public class Operation implements KeyListener 
{ 
Block[] block;//用于储存16个数据 
JPanel panel; 
public boolean up,down,left,right; 
int moveFlag;//用于累计移动的次数 
boolean numFlag;//用于判断是否还能加入新的数字 
public Operation(JFrame frame) 
{ 
this.panel = (JPanel)frame.getContentPane();//构造出panel 
block = new Block[16];//构造出长度为16的数组 
numFlag = true;//初始化 
moveFlag = 0; 
up=true;down=true;left=true;right=true; 
addBlock(); 
for (int i = 0; i < 2; i++) 
appearBlock(); 
frame.addKeyListener(this); 
}

private void addBlock() 
{ 
for (int i = 0; i < 16; i++) //往panel里加入block 
{ 
block[i] = new Block(); 
block[i].setHorizontalAlignment(JLabel.CENTER);// 不透明的标签 
block[i].setOpaque(true); 
panel.add(block[i]); 
} 
} 
public void appearBlock() 
{ 
while (numFlag) //当还能加入随机的一个新的值得时候 
{ 
int index = (int) (Math.random() * 16);//取一个0到15的随机整数，这个数作为随机加入盘中的2或4的位置 
if (block[index].getValue() == 0)//如果这个数所在的block数组中值为0，即在为空的时候，加入一个2或4的数字 
{ 
if (Math.random() < 0.5) 
{ 
block[index].setValue(2); 
} 
else
{ 
block[index].setValue(4); 
} 
break;//跳出while 
} 
} 
}

public void judgeAppear() //统计block数组中是否含有值为0的元素，若没有，则numFlag变为false 
{ 
int sum = 0; 
for (int i = 0; i < 16; i++) 
{ 
if (block[i].getValue() != 0) 
{ 
sum++; 
} 
} 
if (sum == 16) 
numFlag = false;

}

public int Find(int i,int j,int a,int b) 
{ 
while(i<b&&i>=a) 
{ 
if(block[i].getValue()!=0) 
{ 
return i; 
} 
i=i+j; 
} 
return -1; 
} 
public void upBlock() 
{ 
int i=0,j=0;int t=0;int valueJ=0;int valueI=0;int index=0; 
for(i=0;i<4;i++) 
{ 
index=i; 
for(j=i+4;j<16;j+=4) 
{ 
valueJ=0; valueI=0; 
if(block[index].getValue()==0) 
{ 
t=Find(index,4,0,16); 
if(t!=-1) //为每一列的数向上叠加
{ 
block[index].setValue(block[t].getValue()); 
block[t].setValue(0); 
} 
else
{ 
break; 
} 
} 
valueI=block[index].getValue(); 
if(block[j].getValue()==0) 
{ 
t=Find(j,4,0,16); 
if(t!=-1) 
{ 
block[j].setValue(block[t].getValue()); 
block[t].setValue(0); 
} 
else
{ 
break; 
} 
} 
valueJ=block[j].getValue(); 
if(valueI==valueJ&&valueI!=0&&valueJ!=0) 
{ 
block[index].setValue(valueI+valueJ); 
block[j].setValue(0); 
numFlag = true; 
} 
index=j; 
}

} 
} 
public void downBlock() {

int i=0,j=0;int t=0;int valueJ=0;int valueI=0;int index=0; 
for(i=12;i<16;i++) 
{ 
index=i; 
for(j=i-4;j>=0;j-=4) 
{ 
valueJ=0; valueI=0; 
if(block[index].getValue()==0) 
{ 
t=Find(index,-4,0,16); 
if(t!=-1) 
{ 
block[index].setValue(block[t].getValue()); 
block[t].setValue(0); 
} 
else
{ 
break; 
} 
} 
valueI=block[index].getValue(); 
if(block[j].getValue()==0) 
{ 
t=Find(j,-4,0,16); 
if(t!=-1) 
{ 
block[j].setValue(block[t].getValue()); 
block[t].setValue(0); 
} 
else
{ 
break; 
} 
} 
valueJ=block[j].getValue(); 
if(valueI==valueJ&&valueI!=0&&valueJ!=0) 
{ 
block[index].setValue(valueI+valueJ); 
block[j].setValue(0); 
numFlag = true; 
} 
index=j; 
}

} 
} 
public void rightBlock() 
{ 
int i=0,j=0;int t=0;int valueJ=0;int valueI=0;int index=0; 
for(i=3;i<16;i+=4) 
{ 
index=i; 
for(j=i-1;j>i-4;j--) 
{ 
valueJ=0; valueI=0; 
if(block[index].getValue()==0) 
{ 
t=Find(index,-1,i-3,index+1); 
if(t!=-1) 
{ 
block[index].setValue(block[t].getValue()); 
block[t].setValue(0); 
} 
else
{ 
break; 
} 
} 
valueI=block[index].getValue(); 
if(block[j].getValue()==0) 
{ 
t=Find(j,-1,i-3,j+1); 
if(t!=-1) 
{ 
block[j].setValue(block[t].getValue()); 
block[t].setValue(0); 
} 
else
{ 
break; 
} 
} 
valueJ=block[j].getValue(); 
if(valueI==valueJ&&valueI!=0&&valueJ!=0) 
{ 
block[index].setValue(valueI+valueJ); 
block[j].setValue(0); 
numFlag = true; 
} 
index=j; 
}

} 
} 
public void leftBlock() 
{ 
int i=0,j=0;int t=0;int valueJ=0;int valueI=0;int index=0; 
for(i=0;i<16;i+=4) 
{ 
index=i; 
for(j=i+1;j<i+4;j++) 
{ 
valueJ=0; valueI=0; 
if(block[index].getValue()==0) 
{ 
t=Find(index,1,index,i+4); 
if(t!=-1) 
{ 
block[index].setValue(block[t].getValue()); 
block[t].setValue(0); 
} 
else
{ 
break; 
} 
} 
valueI=block[index].getValue(); 
if(block[j].getValue()==0) 
{ 
t=Find(j,1,j,i+4); 
if(t!=-1) 
{ 
block[j].setValue(block[t].getValue()); 
block[t].setValue(0); 
} 
else
{ 
break; 
} 
} 
valueJ=block[j].getValue(); 
if(valueI==valueJ&&valueI!=0&&valueJ!=0) 
{ 
block[index].setValue(valueI+valueJ); 
block[j].setValue(0); 
numFlag = true; 
} 
index=j; 
}

} 
} 
public void over() 
{ 
if (numFlag ==false&& up==false&&down==false&&left==false&&right==false) //当不能添加元素，并且不可移动的步数超过36就输了，输了的时候在盘*显示GAMEOVER 
{ 
block[4].setText("游"); 
block[5].setText("戏"); 
block[6].setText("真"); 
block[7].setText("的"); 
block[8].setText("结"); 
block[9].setText("束"); 
block[10].setText("了"); 
block[11].setText("嗷"); 
block[11].addMouseListener(new MouseAdapter() {public void mousePressed(MouseEvent e){reStart();}}); 
} 
}

public void win() //同OVER 
{ 
block[0].setText("你"); 
block[1].setText("真"); 
block[2].setText("N"); 
block[13].setText("B"); 
block[14].setText("诶"); 
block[15].setText("！"); 
block[15].addMouseListener(new MouseAdapter() { 
public void mousePressed(MouseEvent e) { 
reStart(); 
} 
}); 
} 
public void reStart()//重启游戏，和构造函数类似，不在累述 
{ 
numFlag=true; 
moveFlag=0; 
up=true;down=true;left=true;right=true; 
for(int i=0;i<16;i++) 
block[i].setValue(0); 
for (int i = 0; i < 2; i++) 
appearBlock(); 
} 
public void keyPressed(KeyEvent e) //判断按的上下左右键，并依次调用移动函数、判断函数、添加函数、判断是否输掉的函数 
{ 
switch (e.getKeyCode()) { 
case KeyEvent.VK_UP: 
if(up){ 
upBlock();} 
judgeAppear(); 
appearBlock(); 
over();

if(numFlag==false) 
{ 
up=false; 
} 
else
{ 
up=true;down=true;left=true;right=true; 
} 
break; 
case KeyEvent.VK_DOWN: 
if(down){ 
downBlock();} 
judgeAppear(); 
appearBlock(); 
over(); 
if(numFlag==false) 
{ 
down=false; 
} 
else
{ 
up=true;down=true;left=true;right=true; 
} 
break; 
case KeyEvent.VK_LEFT: 
if(left){ 
leftBlock();} 
judgeAppear(); 
appearBlock(); 
over();

if(numFlag==false) 
{ 
left=false; 
} 
else
{ 
up=true;down=true;left=true;right=true; 
} 
break; 
case KeyEvent.VK_RIGHT: 
if(right){ 
rightBlock();} 
judgeAppear(); 
appearBlock(); 
over();

if(numFlag==false) 
{ 
right=false; 
} 
else
{ 
up=true;down=true;left=true;right=true; 
} 
break; 
}

} 
public void keyTyped(KeyEvent e) {

} 
public void keyReleased(KeyEvent e) {

}

}

颜色模块函数Block：

import javax.swing.*; 
import java.awt.*; 
public class Block extends JLabel 
{ 
private int value; 
public Block() 
{ 
value = 0;//初始化值为0 
setFont(new Font("font", Font.PLAIN, 40));//设定字体 
setBackground(Color.gray);//设定初始颜色为灰色 
}

public int getValue()//获取值 
{ 
return value; 
}

public void setValue(int value) 
{ 
this.value = value; 
String text = String.valueOf(value); 
if (value != 0) 
setText(text); 
else
setText("");//如果值为0则不显示 
setColor(); 
}

public void setColor() //根据值的不同设定不同的背景颜色、label字体 
{ 
switch (value) 
{ 
case 0: 
setBackground(Color.gray); 
break; 
case 2: 
setBackground(new Color(238, 228, 218)); 
break; 
case 4: 
setBackground(new Color(238, 224, 198)); 
break; 
case 8: 
setBackground(new Color(243, 177, 116)); 
break; 
case 16: 
setBackground(new Color(243, 177, 116)); 
break; 
case 32: 
setBackground(new Color(248, 149, 90)); 
break; 
case 64: 
setBackground(new Color(249, 94, 50)); 
break; 
case 128: 
setBackground(new Color(239, 207, 108)); 
break; 
case 256: 
setBackground(new Color(239, 207, 99)); 
break; 
case 512: 
setBackground(new Color(239, 203, 82)); 
break; 
case 1024: 
setBackground(new Color(239, 199, 57)); 
break; 
case 2048: 
setBackground(new Color(239, 195, 41)); 
break; 
case 4096: 
setBackground(new Color(255, 60, 57)); 
break; 
} 
} 
}

PSP时间：

步骤	耗时	百分比
需求分析	30	10%
设计	60	20%
代码实现	180	60%
总结	30	10%

遇到的问题

对于GUI界面开发不熟悉，完全不了解如何做游戏。

解决：先借鉴其他人的代码，学习各种版本游戏中的优点，首先了解一段的功能，然后考虑其是否有可以改进的地方。首先我们找到不同的2048代码进行学习，然后开始进行第一次自主编译，经过多次调试和对照终于完成。

借鉴了其中的Block颜色函数：

　　　　　　　　设置字体与颜色函数 - Font；将不同的数字的背景染成不同颜色；

Operation的对键盘up down right left 扫描功能的函数：

　　　　　　　　首先判断按键然后对每一列每一行扫描，有数字的平移到那一行或那一列最后一个空格中，然后判断前后是否相等，若想等则相加，若不等则放于其下。