实验三

一、实验内容

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));

}

}

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

【实验二】编码标准

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

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

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

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全部修改,否则代码就丢了。

 

【实验五】重构

我们先看看重构的概念:

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

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

重构重要吗？你看看Eclipse菜单中有个refactor菜单就知道了，重构几乎是现代IDE的标配了

我们在编码标准中说“给标识符命名”是程序员一项重要技能，以前没有这个意识，现在知道了怎么办？没问题，上图中重构的第一项功能就是Rename,可以给类、包、方法、变量改名字。 例如这有个ABC类：

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

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

学过C语言的学生学Java时常犯的毛病是不会封装，该用类的地方都用了结构体。比如要定义一个类Student, Eclipse中菜单中的Refactor->Encapsulate Field...,注意分析一下重构前后的代码变化。同样可以封装id和age两个成员变量。

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

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

• 增加新功能；
• 原有功能有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与相应的重构手法如下表所示：

（六）实践项目

1. 以结对编程的方式编写一个软件，Blog中要给出结对同学的Blog网址，可以拍照展现结对编程情况，可以参考一下其他学校的作业

2.记录TDD和重构的过程，测试代码不要少于业务代码，Eclipse中refactor菜单下的重构技能不要少于5个

3.团队代码要使用git在实验楼中托管，要使用结对同学中的一个同学的账号托管。

4. 程序要有GUI界面，参考用户界面和用户体验

5.程序功能从豌豆荚游戏中选择一款用Java实现，注意：团队之间项目不能有重复，课代表协调一下。

6.实验报告中统计自己的PSP(Personal Software Process)时间

队友博客：http://www.cnblogs.com/20135124freedom/p/4552919.html

 

【功能分析】

（1）首先目标是贪吃蛇，我们希望还是简单的方向键控制

（2）其次当贪吃蛇每碰到球一次，贪吃蛇的身体长一个方块

（3）对于分数，我们考虑的每成功吃到球一次，计五分

（4）在GUI视图上，我们准备简单的设计“游戏”“控制”“关于我们”

（5）当玩家控制的贪吃蛇，碰到边缘，则游戏结束。如果想继续游戏，则在“游戏”中寻找“继续游戏”

【分工情况】

张潇月：寻找基础代码以及GUI设计

陈民禾：代码的具体实现和规范

【代码链接】

队友的报告：

【总体设计】

主要包括的类有四个：Snake、Yard、Egg、Dir

1、 Snake

Snake是java版贪吃蛇的主框架，程序的启动类。

2、Yard

Yard主要实现的是

3、Egg

Egg主要就是实现

4、Dir

Dir主要实验

【过程分析】

首先简单说一下GUI的设计，主要是根据我在Matlab课上学到的一些知识，主要是可视化的操作，可供用户选择的界面

1.类代表蛇的运行方向

package javagame;

 

/**

* 代表蛇的方向控制的四种情况

*

* @author 20135124&2035131

*

*/

//控制蛇运行的方向的四种情况

 

public enum Dir {

    L, U, R, D

}

 

2.类Egg用于表示苹果在贪吃蛇这个游戏中的设计：

 

package javagame;

 

import java.awt.Color;

import java.awt.Graphics;

import java.awt.Rectangle;

import java.util.Random;

 

/**

* @author Administrator

*

*/

//用于表示苹果在贪吃蛇这个游戏中的设计：

public class Egg {

    int row, col;//设定行列

    int w = Yard.BLOCK_SIZE;

    int h = Yard.BLOCK_SIZE;

    private static Random r = new Random();

    private Color color = Color.GREEN;//将贪吃蛇中苹果的颜色设置为绿色

 

    public Egg(int row, int col) {

        this.row = row;

        this.col = col;

    }

 

    public Egg() {

        this(r.nextInt(Yard.ROWS - 2) + 2, r.nextInt(Yard.COLS));//根据贪吃蛇的移动来确定下次苹果所在的坐标

    }

 

    public void reAppear() {

        this.row = r.nextInt(Yard.ROWS - 2) + 2;

        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.GREEN)

            color = Color.RED;

        else

            color = Color.GREEN;

    }

 

    public int getCol() {

        return col;//苹果的颜色

    }

 

    public void setCol(int col) {

        this.col = col;//设置苹果的列坐标

    }

 

    public int getRow() {

        return row;//获取苹果的行坐标

    }

 

    public void setRow(int row) {

        this.row = row;//设置苹果的行坐标

    }

 

}

3.是对蛇的运行过程的控制

package javagame;

 

import java.awt.Color;

import java.awt.Graphics;

import java.awt.Rectangle;

import java.awt.event.KeyEvent;

/**

* 代表蛇

* @author Administrator

*

*/

 

public class Snake {

    private Node head = null;

    private Node tail = null;

    private int size = 0;

  

    private Node n = new Node(20, 30, Dir.L);

    private 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 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);

        }

    }

  

    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;

        tail.next = null;

      

    }

 

    private class Node {

        int w = Yard.BLOCK_SIZE;

        int h = Yard.BLOCK_SIZE;

        int row , col;

        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.GREEN);

            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);

        }

    }

  

    private 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.R)

                head.dir = Dir.L;

            break;

        case KeyEvent.VK_DOWN :

            if(head.dir != Dir.U)

                head.dir = Dir.D;

            break;

        }

    }

}

4.类Yard表示它的活动场所

package javagame;

import java.awt.*;

import java.awt.event.*;

import javax.swing.JOptionPane;

/**

* 这个类代表贪吃蛇的活动场所

*/

public class Yard extends Frame implements ActionListener{

         PaintThread paintThread = new PaintThread();

         private boolean gameOver = false; //游戏是否结束

       

       

         /**

          * 行数

          */

             public static boolean printable = true;

        private static final long serialVersionUID = 1L;

        MenuBar jmb = null;

             Menu jm1 = null, jm2 = null, jm3 = null;

             MenuItem jmi1 = null, jmi2 = null, jmi3 = null, jmi4 = null, jmi5 = null;

         public static final int ROWS = 30;

         public static final int COLS = 30;

         public static final int BLOCK_SIZE = 25;

    

         private Font fontGameOver = new Font("楷体", Font.BOLD, 50);

    private Font fontscore = new Font("楷体", Font.BOLD, 20);

       

         private int score = 0;

       

         Snake s = new Snake(this);

         Egg e = new Egg();

       

         Image offScreenImage = null;

       

         public void launch() {

    printable = false;// 创建菜单及菜单选项

                  jmb = new MenuBar();

                  jm1 = new Menu("游戏");

                  jm2 = new Menu("控制");

                  jm3 = new Menu("帮助");

                  jm1.setFont(new Font("TimesRoman", Font.BOLD, 15));// 设置菜单显示的字体

                  jm2.setFont(new Font("TimesRoman", Font.BOLD, 15));// 设置菜单显示的字体

                  jm3.setFont(new Font("TimesRoman", Font.BOLD, 15));// 设置菜单显示的字体

                  jmi1 = new MenuItem("开始新游戏");

                  jmi2 = new MenuItem("退出");

                  jmi3 = new MenuItem("暂停");

                  jmi4 = new MenuItem("继续");

                  jmi5 = new MenuItem("关于我们");

                  jmi1.setFont(new Font("TimesRoman", Font.BOLD, 15));

                  jmi2.setFont(new Font("TimesRoman", Font.BOLD, 15));

                  jmi3.setFont(new Font("TimesRoman", Font.BOLD, 15));

                  jmi4.setFont(new Font("TimesRoman", Font.BOLD, 15));

                  jmi5.setFont(new Font("TimesRoman", Font.BOLD, 15));

                

                  jm1.add(jmi1);

                  jm1.add(jmi2);

                  jm2.add(jmi3);

                  jm2.add(jmi4);

                  jm3.add(jmi5);

                  jmb.add(jm1);

                  jmb.add(jm2);

                  jmb.add(jm3);

        //设置各个按钮

                  jmi1.addActionListener(this);

                  jmi1.setActionCommand("NewGame");

                  jmi2.addActionListener(this);

                  jmi2.setActionCommand("Exit");

                  jmi3.addActionListener(this);

                  jmi3.setActionCommand("Stop");

                  jmi4.addActionListener(this);

                  jmi4.setActionCommand("Continue");

                  jmi5.addActionListener(this);

                  jmi5.setActionCommand("help");

                  this.setMenuBar(jmb);// 菜单Bar放到JFrame上

                  this.setVisible(true);

                  this.setLocation(300, 65);//分配GUI界面所占的空间

                  this.setSize(COLS * BLOCK_SIZE, ROWS * BLOCK_SIZE);//设置GUI界面所占的空间

                  this.addWindowListener(new WindowAdapter() {

                          @Override

                          public void windowClosing(WindowEvent e) {

                                   System.exit(0);

                          }

                        

                  });

                  this.setVisible(true);

                  this.addKeyListener(new KeyMonitor());

                

                  new Thread(paintThread).start();//设置start

         }

       

         public static void main(String[] args) {

                  new Yard().launch();

         }

         public void stop() {

                  gameOver = true;//设置gameover】

       

         }

       

         @Override

         public void paint(Graphics g) {

                  Color c = g.getColor();

                  g.setColor(Color.WHITE);

                  g.fillRect(0, 0, COLS * BLOCK_SIZE, ROWS * BLOCK_SIZE);

                this.setTitle("贪吃蛇——(方向键控制)");

                g.setColor(Color.DARK_GRAY);//画出横线

                  for(int i=1; i<ROWS; i++) {

                          g.drawLine(0, BLOCK_SIZE * i, COLS * BLOCK_SIZE, BLOCK_SIZE * i);

                  }

                  for(int i=1; i<COLS; i++) {

                          g.drawLine(BLOCK_SIZE * i, 0, BLOCK_SIZE * i, BLOCK_SIZE * ROWS);

                  }

                

                  g.setColor(Color.RED);

                g.setFont(fontscore);

                  g.drawString("得分:" + score, 30,100);//每次吃到果子后界面显示

                

                  if(gameOver) {

                          g.setFont(fontGameOver);

                          g.drawString("游戏结束", 280, 350);//结束后的得分显示及状况

                        

                          paintThread.pause();

                  }

                

                  g.setColor(c);

                

                  s.eat(e);

                  e.draw(g);

                  s.draw(g);

                

                

         }

       

         @Override

         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 {

                  private boolean running = true;

                  private boolean pause = false;

                  public void run() {

                          while(running) {

                                   if(pause) continue;

                                   else repaint();

                                 

                                   try {

                                            Thread.sleep(100);

                                   } catch (InterruptedException e) {

                                            e.printStackTrace();

                                   }

                          }

                  }

                

                  public void pause() {

                          this.pause = true;

                  }

                

                  public void reStart() {

                          this.pause = false;

                          s = new Snake(Yard.this);

                          gameOver = false;

                  }

                

                  @SuppressWarnings("unused")

                  public void gameOver() {

                          running = false;

                  }

                

         }

       

         private class KeyMonitor extends KeyAdapter {

                  @Override

                  public void keyPressed(KeyEvent e) {

                          int key = e.getKeyCode();

                          if(key == KeyEvent.VK_F2) {

                                   paintThread.reStart();

                          }

                          s.keyPressed(e);

                  }

                

         }

       

         /**

          * 拿到所得的分数

          * @return 分数

          */

       

         public int getScore() {

                  return score;

         }

       

         /**

          * 设置所得的分数

          * @param score 分数

          */

       

         public void setScore(int score) {

                  this.score = score;

         }

public void actionPerformed(ActionEvent e) {

                  if (e.getActionCommand().equals("NewGame")) {

                          printable = false;

                          Object[] options = { "确定", "取消" };

                          int response = JOptionPane.showOptionDialog(this, "once again？", "",

                                            JOptionPane.YES_OPTION, JOptionPane.QUESTION_MESSAGE, null,

                                            options, options[0]);

                          if (response == 0) {

                                   printable = true;

                                   this.dispose();

                                   new Yard().launch();

                          } else {

                                   printable = true;

                                   new Thread(new PaintThread()).start(); // 线程启动

                          }

                  } else if (e.getActionCommand().endsWith("Stop")) {

                          printable = false;

                           try {

                           Thread.sleep(200);

                        

                           } catch (InterruptedException e1) {

                          

                          e1.printStackTrace();

                   }

                  } else if (e.getActionCommand().equals("Continue")) {

                          if (!printable) {

                                   printable = true;

                                   new Thread(new PaintThread()).start(); // 线程启动

                          }

                  } else if (e.getActionCommand().equals("Exit")) {

                          printable = false;

                          Object[] options = { "确定", "取消" };

                          int response = JOptionPane.showOptionDialog(this, "您确认要退出吗", "",

                                            JOptionPane.YES_OPTION, JOptionPane.QUESTION_MESSAGE, null,

                                            options, options[0]);

                          if (response == 0) {

                                   System.out.println("退出");

                                   System.exit(0);

                          } else {

                                   printable = true;

                                   new Thread(new PaintThread()).start(); // 线程启动

                          }

                  } else if (e.getActionCommand().equals("help")) {

                          printable = false;

                          JOptionPane.showMessageDialog(null, "由于初学者许多功能都不完善，请大家见谅",

                                            "提示！", JOptionPane.INFORMATION_MESSAGE);

                                 this.setVisible(true);

                                 printable = true;

                          new Thread(new PaintThread()).start(); // 线程启动

}

}

}

初始化界面：

后来界面：

三、遇到的问题及解决方法

1.未能按照要求编写出TDD

解决方法：从网上查阅了资料，并结合上次实验过程，了解了TDD的含义与作用，但是只是停留在了理解的层次，还不能做到自己灵活地编写、运用；

2.git实现过程十分艰难

解决方案：一开始弄不明白自己到底该怎么做，后来在同学的指点下，结合老师给的指导书才慢慢的把git这部分给弄好。花费了大量的时间。

四、实验体会

这次实验中所讲解的java程序架构思想与练习的重构的内容老师在课上都已提到过，或者详细的讲解过，但即使老师讲的很清楚了，自己还是不能得心应手地运用。并且在git这部分自己浪费了非常多的时间，还似懂非懂。觉得自己还是要在这上面好好下功夫。