北京电子科技学院（BESTI）
实 验 报 告
课程：Java 班级：1351班 姓名：臧文君 学号：20135115
成绩： 指导教师：娄嘉鹏 实验日期：2015.6.4
实验密级：无 预习程度： 实验时间：15:30-18:00
仪器组次： 必修/选修：选修 实验序号：三
实验名称： 敏捷开发与XP实践
实验目的与要求： 1.没有Linux基础的同学建议先学习《Linux基础入门（新版）》《Vim编辑器》 课程。
2.完成实验、撰写实验报告，实验报告以博客方式发表在博客园，注意实验报告重点是运行结果，遇到的问题(工具查找，安装，使用，程序的编辑，调试，运行等)、解决办法（空洞的方法如“查网络”、“问同学”、“看书”等一律得0分）以及分析（从中可以得到什么启示，有什么收获，教训等）。报告可以参考范飞龙老师的指导。
3. 严禁抄袭，有该行为者实验成绩归零，并附加其他惩罚措施。
实验仪器：
|
名称 |
型号 |
数量 |
|
笔记本电脑 |
Lenovo Z485 |
1台 |
|
|
|
|
实验内容、步骤与体会（附纸）：
一、实验内容
1. XP基础
2. XP核心实践
3. 相关工具
4.结对同学：20135207 王国伊
Blog网址：www.cnblogs.com/20135207oneking
二、实验步骤
（一）敏捷开发与XP
1、软件工程
（1）包括：软件需求分析、软件设计、软件构建、软件测试和软件维护。
（2）软件工程=开发流程+工具。
软件=程序+软件工程，软件企业=软件+商业模式。
（3）常见的开发流程：
RUP(Rational Unified Process)
PSP(Personal Software Process )
TSP(Team Software Process )
Agile Process
2、敏捷开发（Agile Development）
（1）含义：是一种以人为核心、迭代、循序渐进的开发方法。
（2）模式：XP,TDD,CI,FDD,BDD,SCRUM,Feature Team,Domain Model,Extract Activities,Refactor,Pair Programming,Feature List/Product Backlog.
（3）极限编程(eXtreme Programming，XP) 是一种全新而快捷的软件开发方法。
（4）XP准则：沟通，简单，反馈，勇气。
（5）XP活动：编码，测试，倾听，设计。
（二）编码标准
1、包含：具有说明性的名字、清晰的表达式、直截了当的控制流、可读的代码和注释，以及在追求这些内容时一致地使用某些规则和惯用法的重要性。
2、Eclipse中的快捷键使用：
Ctrl+Shift+F或菜单中的source->Format，使代码按Eclipse规定的规范缩进。
3、Java中的一般的命名规则：
（1）要体现各自的含义；
（2）包、类、变量用名词；
（3）方法名用动宾；
（4）包名全部小写，如：io，awt；
（5）类名第一个字母要大写，如：HelloWorldApp；
（6）变量名第一个字母要小写，如：userName；
（7）方法名第一个字母要小写：setName。
4、标识符
一般采用英文单词或其组合，切忌使用汉语拼音来命名，可以通过去元音法把变量名缩短。
（三）结对编程
1、分为：驾驶员（Driver）是控制键盘输入的人。
领航员（Navigator）起到领航、提醒的作用。
2、驾驶员：写设计文档，进行编码和单元测试等XP开发流程。
领航员：审阅驾驶员的文档、驾驶员对编码等开发流程的执行；考虑单元测试的覆盖率；思考是否需要和如何重构；帮助驾驶员解决具体的技术问题。
（四）版本控制
1、版本控制提供项目级的 undo（撤销） 功能。
2、版本控制允许多人在同一代码上工作， 只要遵守一定的控制原则就行。
3、版本控制系统保存了过去所作的修改的历史记录。
4、版本控制系统还支持在主线上开发的同时发布多个软件版本。
5、版本控制也是项目级的时间机器，你可以选择任何一个时间， 精确地查看项目在当时的情况。
6、流行的版本控制工具有CVS，SVN，Git等。
7、实验楼中的git服务：
（1）公开的代码仓库：shiyanlou_cs212
（2）启动实验时，会自动执行git pull，获取课程仓库中的最新代码，存放于/home/shiyanlou/Code目录。
（3）进入到实验环境中修改代码，完成后需要依次执行下述命令即可提交：
$ cd /home/shiyanlou/Code/shiyanlou_cs212
# 修改代码文件
# 添加修改文件
$ git add 所有修改的文件
# 提交到环境中本地代码仓库
$ git commit -m '本次修改的描述'
# push到git.shiyanlou.com，无需输入密码
$ git push
例：
（4）克隆其他用户代码仓库只需要知道对方的仓库链接，我们鼓励在别人代码基础上修改：
$ git clone http://git.shiyanlou.com/[对方的专属用户名]/[课程代码仓库名]
（5）输入git status：查看代码状态；
出现未跟踪的文件，使用git add <file>...：以包含要提交的内容；
使用git commit：git将依据索引库中的内容来进行文件的提交；
使用git push：把代码保存到远程托管服务器中。
（五）重构（Refactor）
1、概念：重构是在不改变软件外部行为的基础上，改变软件内部的结构，使其更加易于阅读、易于维护和易于变更。
2、重构的第一项功能---Rename
可以给类、包、方法、变量改名字。
修改方法：用鼠标单击要改的名字，选择Eclipse中菜单中的Refactor->Rename...
例：
3、重构的第二项功能---封装
修改方法：Refactor->Encapsulate Field...
例：
选择需要封装的变量s.name，点击Refactor->Encapsulate Field。
用同样的方法封装age和id。
使用Eclipse中Source->Generate toString()，给Student类产生一个toString方法。
4、修改代码的目的：
增加新功能，原有功能有BUG，改善原有程序的结构，优化原有系统的性能。
5、有Bad Smell的代码需要重构：
重复代码（Duplicated Code），过长方法，过长参数列，条件逻辑过度复杂，分支语句，基本类型迷恋，数据泥团。
6、Eclipse中Refactor菜单中的重构手法的应用时机如下图所示：
7、重构的完整流程：
（1）从版本控制系统代码库中Check out code；
（2）读懂代码（包括测试代码）；
（3）发现bad smell；
（4）Refactoring；
（5）运行所有的Unit Tests；
（6）往代码库中Check in code；
（六）实践项目
编写小游戏：黑白棋。
结对同学：20135207 王国伊
Blog网址：www.cnblogs.com/20135207oneking
1、实验分工：臧文君---TDD测试代码，Chess、ChessListener代码的重构。
王国伊---代码分析，GUI界面的实现。
2、实验步骤：
（1）先查找黑白棋的游戏规则，分析代码需要实现的内容：
a.下棋子时相应的棋子颜色改变；
b.统计黑白双方现有棋子的个数以及每下一步改变棋子的个数；
c.分析棋手还有几种下发。
（2）在网上搜索相关代码，克隆下来。
（3）分析代码中语句的功能，根据TDD思想编写测试代码。
（4）根据测试结果，由臧文君负责代码中变量名称、方法的重构，由王国伊负责GUI界面的实现。
（5）将两个人的代码进行综合，测试结果。
3、黑白棋游戏代码：
package Chess;
import static org.junit.Assert.*;
import Chess.ChessListener;
import org.junit.Test;
public class ChessTest {
@Test
public void testNormal() {
ChessListener a = new ChessListener(null, null, null, null, null);
assertEquals(2,a.makeout()); //1代表黑方获胜，2代表白方获胜，0代表平局
}
}
package Chess;
import java.awt.Dimension;
import java.awt.Font;
import java.awt.Graphics;
import java.awt.GridLayout;
import java.awt.Image;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import javax.swing.ImageIcon;
import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.JPanel;
@SuppressWarnings("serial")
public class Chess extends JFrame {
public static void main(String args[]){
Chess ch = new Chess();
ch.showframe();
}
//显示游戏界面
public void showframe(){
//--------------------游戏界面----------------------
JPanel gamejp = new JPanel();
//--------------------组件界面----------------------
JPanel buttonjp = new JPanel();
//按钮图标
ImageIcon blackchess = new ImageIcon("E:/JavaCode/Test/Test/image/黑子.jpg");
ImageIcon whitechess = new ImageIcon("E:/JavaCode/Test/Test/image/白子.jpg");
ImageIcon black = new ImageIcon("E:/JavaCode/Test/Test/image/黑子.jpg");
ImageIcon white = new ImageIcon("E:/JavaCode/Test/Test/image/白子.jpg");
JButton blackbutton = new JButton(blackchess);
JButton whitebutton = new JButton(whitechess);
blackbutton.setRolloverIcon(black);
whitebutton.setRolloverIcon(white);
blackbutton.setPressedIcon(black);
whitebutton.setPressedIcon(white);
Dimension di = new Dimension(100,100);
blackbutton.setPreferredSize(di);
whitebutton.setPreferredSize(di);
//-----------------------当前下棋的人---------------------
final JLabel record = new JLabel(" 黑方下 ");
//设置字体
Font recordfont = new Font("黑体",Font.BOLD,30);
record.setFont(recordfont);
//用来记录阿狸与桃子的数目
final JLabel blacknum = new JLabel("2");
final JLabel whitenum = new JLabel("2");
//设置Label的字体和大小
Font font = new Font("宋体",Font.BOLD,42);
blacknum.setFont(font);
whitenum.setFont(font);
//-----------------重新开局的方法------------------
ImageIcon img = new ImageIcon("E:/JavaCode/Test/Test/image/restart.jpg");
JButton bu = new JButton(img);
bu.setPreferredSize(new Dimension(200,200));
buttonjp.add(record);
buttonjp.add(blackbutton);
buttonjp.add(blacknum);
buttonjp.add(whitebutton);
buttonjp.add(whitenum);
buttonjp.add(bu);
this.setLayout(new GridLayout(1,2,600,0));
this.add(gamejp);
this.add(buttonjp);
this.setTitle("黑白棋--双人对战");
this.setSize(1000,650);
this.setResizable(false);
this.setLocationRelativeTo(null);
this.setDefaultCloseOperation(3);
//显示窗口
this.setVisible(true);
//获取画布权限
Graphics g = this.getGraphics();
chess[3][3]=1;
chess[4][4]=1;
chess[3][4]=-1;
chess[4][3]=-1;
ChessListener listener = new ChessListener(g,this,record,blacknum,whitenum);
this.addMouseListener(listener);
//按钮监听器----------------重新开始
ActionListener buttonlistener = new ActionListener(){
public void actionPerformed(ActionEvent e){
clear();
//重绘的方法
repaint();
//绘制初始的四个图片
chess[3][3]=1;
chess[4][4]=1;
chess[3][4]=-1;
chess[4][3]=-1;
//将状态改为初始状态
ChessListener.stata=1;
record.setText(" 黑方下 ");
blacknum.setText("2");
whitenum.setText("2");
}
};
//如果点击黑方则黑方下
ActionListener blacklistener = new ActionListener(){
public void actionPerformed(ActionEvent e){
ChessListener.stata=1;
record.setText(" 黑方下 ");
}
};
//如果点击白方则白方下
ActionListener whitelistener = new ActionListener(){
public void actionPerformed(ActionEvent e){
ChessListener.stata=-1;
record.setText(" 白方下 ");
}
};
blackbutton.addActionListener(blacklistener);
whitebutton.addActionListener(whitelistener);
bu.addActionListener(buttonlistener);
}
public void clear(){
for(int i=0;i<chess.length;i++){
for(int j=0;j<chess[i].length;j++){
chess[i][j]=0;
}
}
}
public void paint(Graphics g){
super.paint(g);
Image back = new ImageIcon("E:/JavaCode/Test/Test/image/棋盘.jpg").getImage();
g.drawImage(back, 10,30,600,600, null);
//绘制棋子
for(int i=0;i<rows-1;i++){
for(int j=0;j<cols-1;j++){
int X=x+size/2+size*i;//棋子的横坐标
int Y=y+size/2+size*j;//棋子的纵坐标
if(chess[i][j]==1){
//画黑棋
Image b = new ImageIcon("E:/JavaCode/Test/Test/image/黑子.jpg").getImage();
g.drawImage(b, X-Chess_size/2, Y-Chess_size/2, Chess_size, Chess_size, null);
}
else if(chess[i][j]==-1){
//画白棋
Image w = new ImageIcon("E:/JavaCode/Test/Test/image/白子.jpg").getImage();
g.drawImage(w, X-Chess_size/2, Y-Chess_size/2, Chess_size, Chess_size, null);
}
}
}
}
public final static int x=63; //棋盘初始点横坐标
public final static int y=85; //棋盘初始点纵坐标
public final static int rows=9; //棋盘行数
public final static int cols=9; //棋盘列数
public final static int size=61;//棋盘格子大小
public final static int Chess_size=60;//棋子大小
public final static int chess[][]=new int[rows-1][cols-1];//定义一个8*8的数组，用来保存棋子
}
package Chess;
import java.awt.Graphics;
import java.awt.event.MouseAdapter;
import java.awt.event.MouseEvent;
import javax.swing.JLabel;
import javax.swing.JOptionPane;
public class ChessListener extends MouseAdapter{
private Graphics g; //将画布对象传过来
private int skill; //记录当前棋子的下法
public static int stata=1;//判断下黑棋还是白棋
private int x1,y1; //记录点击处的横坐标和纵坐标
private JLabel record; //当前下棋子的人
private JLabel blacknum; //黑方棋子数
private JLabel whitenum; //白方棋子数
private Chess ch; //用来刷新棋盘
private int special=0; //特殊情况
private int change; //记录改变的棋子数目
public ChessListener(Graphics g,Chess ch,JLabel record,JLabel blacknum,JLabel whitenum){
this.g=g;
this.ch=ch;
this.record=record;
this.blacknum=blacknum;
this.whitenum=whitenum;
}
//点击下棋子
public void mouseClicked(MouseEvent e){
int a=1; //记录所下的子
String s = null;
x1=e.getX();
y1=e.getY();
for(int i=0;i<Chess.rows-1;i++){
for(int j=0;j<Chess.cols-1;j++){
int x2=Chess.x+Chess.size/2+Chess.size*i;//得到棋盘中棋子所在点的横坐标
int y2=Chess.y+Chess.size/2+Chess.size*j;//得到棋盘中棋子所在点的纵坐标
//将棋子下在棋盘格子的正中央
if(Math.abs(x1-x2)<Chess.size/3&&Math.abs(y1-y2)<Chess.size/3){
if(Chess.chess[i][j]==0){
if(stata==1)
stata=-1;
else if(stata==-1)
stata=1;
Chess.chess[i][j]=-stata;//将棋子存入棋盘
//--------------如果8个方向都不能改变棋子则不改变棋盘状态--------------
if (hengYou(i, j) == null && hengZuo(i, j) == null && hengShang(i, j) == null && hengXia(i, j) == null && xieyouS(i, j) == null && xieyouX(i, j) == null && xiezuoS(i, j) == null && xiezuoX(i, j) == null) {
Chess.chess[i][j]=0;
if(stata==1){
stata=-1;
}
else if(stata==-1){
stata=1;
}
//刷新棋盘
ch.update(g);
JOptionPane.showMessageDialog(null, "不能放子");
}
else{
// 改变中间子颜色
hengYou1(i, j);
hengZuo1(i, j);
hengShang1(i, j);
hengXia1(i, j);
xieyou1(i, j);
xieyou2(i, j);
xiezuo1(i, j);
xiezuo2(i, j);
// 以坐标为圆心画圆
ch.update(g);
//改变棋子记录框里面的数字
blacknum.setText(judge()[0]+"");
whitenum.setText(judge()[1]+"");
System.out.println("改变了"+change+"个子");
change=0;
//判断当前下棋的人
if(stata==1){
record.setText(" 黑方下 ");
a=1;
s="黑方";
}
else if(stata==-1){
record.setText(" 白方下 ");
a=-1;
s="白方";
}
skill=Check(a);
//输出当前下棋的人还有几种下法
System.out.println(s+"有"+skill+"种下法");
if(skill==0&&full()==false){//如果不能下子并且棋盘未满
special++;
JOptionPane.showMessageDialog(null, s+"不能下子，跳过!");
if(stata==1){//如果黑方不能下子则跳过，白方下
stata=-1;
record.setText(" 白方下 ");
a=-1;
s="白方";
}
else if(stata==-1){//如果白方不能下子则跳过，黑方下
stata=1;
record.setText(" 黑方下 ");
a=1;
s="黑方";
}
skill=Check(a);
System.out.println(s+"有"+skill+"种下法");
if(skill==0){
special++;//如果无子可下，则特殊情况记录加1
}else
special=0;
}
//----------------胜负判断----------------
makeout();
}
}
}
}
}
}
public int makeout() {
if(judge()[0]==0){//如果黑方没子了则白方获胜
JOptionPane.showMessageDialog(null,"游戏结束，白方获胜");
return 2;
}
else if(judge()[1]==0){//如果白方没子了则黑方获胜
JOptionPane.showMessageDialog(null, "游戏结束，黑方获胜");
return 1;
}
if(full()){
if(judge()[0]>judge()[1]){//如果黑方的子较多，则黑方获胜
JOptionPane.showMessageDialog(null, "游戏结束，黑方获胜");
return 1;
}
else if(judge()[0]<judge()[1]){//如果白方的子较多，则白方获胜
JOptionPane.showMessageDialog(null, "游戏结束，白方获胜");
return 2;
}
else if(judge()[0]==judge()[1]){
JOptionPane.showMessageDialog(null, "平局");
return 0;
}
}
return 3;
}
/* 判断输赢的方法，如果黑棋多则黑棋获胜，否则白棋获胜
@return 黑棋和白棋的数目 */
public int[] judge(){
int count[]=new int[2];
for(int i=0;i<Chess.rows-1;i++){
for(int j=0;j<Chess.cols-1;j++){
if(Chess.chess[i][j]==1){
count[0]++;
}
else if(Chess.chess[i][j]==-1){
count[1]++;
}
}
}
return count;
}
/* 判断棋盘是否已满的方法 */
public boolean full(){
if(special==2){ //如果双方都不能下子，则游戏结束
return true;
}
else{
for(int i=0;i<Chess.rows-1;i++){
for(int j=0;j<Chess.cols-1;j++){
//如果有一个地方是空的则返回false
if(Chess.chess[i][j]==0){
return false;
}
}
}
}
return true;
}
/* 判断当前棋子的下法还有多少种
@param return 返回下法的总数 */
public int Check(int a){
int n=0;
for(int i=0;i<Chess.chess.length;i++){
for(int j=0;j<Chess.chess[i].length;j++){
if(Chess.chess[i][j]!=0){
continue;
}
else{
Chess.chess[i][j]=a;
if(hengYou(i, j) != null || hengZuo(i, j) != null || hengShang(i, j) != null || hengXia(i, j) != null || xieyouS(i, j) != null || xieyouX(i, j) != null || xiezuoS(i, j) != null || xiezuoX(i, j) != null){
Chess.chess[i][j]=0;
n++; //如果有一个地方可以下子，则n+1
}
else{
Chess.chess[i][j]=0;
}
}
}
}
return n;
}
/*********************************************** 检测相同颜色 *******************************/
/* 改变两棋子之间的棋子的颜色——直线 */
public void paintChess(int r1, int c1, int r2, int c2) {
// 横向
if (c1 == c2) {
for (int k = Math.min(r1, r2) + 1; k < Math.max(r1, r2); k++) {
Chess.chess[k][c1] = Chess.chess[r1][c1];
change++;
}
}
// 纵向
if (r1 == r2) {
for (int k = Math.min(c1, c2) + 1; k < Math.max(c1, c2); k++) {
Chess.chess[r1][k] = Chess.chess[r1][c1];
change++;
}
}
}
/* 改变两棋子之间的棋子的颜色——斜线——右上 */
public void paintChess1(int r1, int c1, int r2, int c2) {
for (int k = Math.min(r1, r2) + 1, v = Math.max(c1, c2) - 1; k < Math
.max(r1, r2); k++, v--) {
Chess.chess[k][v] = Chess.chess[r1][c1];
change++;
}
}
/* 改变两棋子之间的棋子的颜色——斜线——右下 */
public void paintChess2(int r1, int c1, int r2, int c2) {
for (int k = Math.min(r1, r2) + 1, v = Math.min(c1, c2) + 1; k < Math
.max(r1, r2); k++, v++) {
Chess.chess[k][v] = Chess.chess[r1][c1];
change++;
}
}
/* 改变两棋子之间的棋子的颜色——斜线——左上 */
public void paintChess3(int r1, int c1, int r2, int c2) {
for (int k = Math.max(r1, r2) - 1, v = Math.max(c1, c2) - 1; k > Math
.min(r1, r2); k--, v--) {
Chess.chess[k][v] = Chess.chess[r1][c1];
change++;
}
}
/* 改变两棋子之间的棋子的颜色——斜线——左下 */
public void paintChess4(int r1, int c1, int r2, int c2) {
for (int k = Math.min(r1, r2) + 1, v = Math.max(c1, c2) - 1; k <= Math
.max(r1, r2); k++, v--) {
Chess.chess[k][v] = Chess.chess[r1][c1];
change++;
}
}
/* 向右检测是否有相同颜色棋子，如果有且不相邻，改变中间棋子颜色，否则返回NULL */
public int[] hengYou(int x, int y) {
int r = -2;
int i;
// 向右
for (i = x + 1; i < Chess.rows-1; i++) {
if (Chess.chess[i][y] != 1 && Chess.chess[i][y] != -1)
break;
if (Chess.chess[i][y] == Chess.chess[x][y]) {
r = i;
break;
}
}
if (r != -2 && Chess.chess[x + 1][y] != Chess.chess[i][y]) {
return new int[] { r, y };
}
else
return null;
}
/* 向左检测是否有相同颜色棋子，如果有且不相邻，改变中间棋子颜色，否则返回NULL */
public int[] hengZuo(int x, int y) {
int r = -2;
int i;
// 向左
for (i = x - 1; i >= 0; i--) {
if (Chess.chess[i][y] != 1 && Chess.chess[i][y] != -1) {
break;
}
if (Chess.chess[i][y] == Chess.chess[x][y]) {
r = i;
break;
}
}
if (r != -2 && Chess.chess[x - 1][y] != Chess.chess[i][y]) {
return new int[] { r, y };
}
else
return null;
}
/* 向上检测是否有相同颜色棋子，如果有且不相邻，改变中间棋子颜色，否则返回NULL */
public int[] hengShang(int x, int y) {
int r = -2;
int i;
// 向上
for (i = y - 1; i >= 0; i--) {
if (Chess.chess[x][i] == 0)
break;
if (Chess.chess[x][i] == Chess.chess[x][y]) {
r = i;
break;
}
}
if (r != -2 && Chess.chess[x][y - 1] != Chess.chess[x][i]) {
return new int[] { x, r };
}
else
return null;
}
/* 向上检测是否有相同颜色棋子，如果有且不相邻，改变中间棋子颜色，否则返回NULL */
public int[] hengShang1(int x, int y) {
int r = -2;
int i;
// 向上
for (i = y - 1; i >= 0; i--) {
if (Chess.chess[x][i] == 0)
break;
if (Chess.chess[x][i] == Chess.chess[x][y]) {
r = i;
break;
}
}
if (r != -2 && Chess.chess[x][y - 1] != Chess.chess[x][i]) {
// 改变中间的子
paintChess(x, y, x, r);
return new int[] { x, r };
}
else
return null;
}
/* 向下检测是否有相同颜色棋子，如果有且不相邻，改变中间棋子颜色，否则返回NULL */
public int[] hengXia(int x, int y) {
int r = -2;
int i;
// 向下
for (i = y + 1; i < Chess.rows-1; i++) {
if (Chess.chess[x][i] == 0)
break;
if (Chess.chess[x][i] == Chess.chess[x][y]) {
r = i;
break;
}
}
if (r != -2 && Chess.chess[x][y + 1] != Chess.chess[x][i]) {
return new int[] { x, r };
}
else
return null;
}
/* 向下检测是否有相同颜色棋子，如果有且不相邻，改变中间棋子颜色，否则返回NULL */
public int[] hengXia1(int x, int y) {
int r = -2;
int i;
// 向下
for (i = y + 1; i < Chess.rows-1; i++) {
if (Chess.chess[x][i] == 0)
break;
if (Chess.chess[x][i] == Chess.chess[x][y]) {
r = i;
break;
}
}
if (r != -2 && Chess.chess[x][y + 1] != Chess.chess[x][i]) {
// 改变中间的子
paintChess(x, y, x, r);
return new int[] { x, r };
}
else
return null;
}
/* 斜右上方向 */
public int[] xieyouS(int x, int y) {
// 向上
int r = -2, s = -2;
int i, j;
for (i = x + 1, j = y - 1; i < Chess.rows-1 && j >= 0; i++, j--) {
if (Chess.chess[i][j] == 0)
break;
if (Chess.chess[i][j] == Chess.chess[x][y]) {
r = i;
s = j;
break;
}
}
if (r != -2 && s != -2 && Chess.chess[x + 1][y - 1] != Chess.chess[i][j]) {
return new int[] { r, s };
}
else
return null;
}
/* 斜右下方向 */
public int[] xieyouX(int x, int y) {
// 向下
int r = -2, s = -2;
int i, j;
for (i = x + 1, j = y + 1; i < Chess.rows-1 && j < Chess.cols-1; i++, j++) {
if (Chess.chess[i][j] == 0)
break;
if (Chess.chess[i][j] == Chess.chess[x][y]) {
r = i;
s = j;
break;
}
}
if (r != -2 && s != -2
&& Chess.chess[x + 1][y + 1] != Chess.chess[i][j]) {
return new int[] { r, s };
}
else
return null;
}
/* 斜左上方向 */
public int[] xiezuoS(int x, int y) {
// 向上
int r = -2, s = -2;
int i, j;
for (i = x - 1, j = y - 1; i >= 0 && j >= 0; i--, j--) {
if (Chess.chess[i][j] == 0)
break;
if (Chess.chess[i][j] == Chess.chess[x][y]) {
r = i;
s = j;
break;
}
}
if (r != -2 && s != -2 && Chess.chess[x - 1][y - 1] != Chess.chess[i][j]) {
return new int[] { r, s };
}
else
return null;
}
/* 斜左下方向 */
public int[] xiezuoX(int x, int y) {
// 向下
int r = -2, s = -2;
int i, j;
for (i = x - 1, j = y + 1; i >= 0 && j < Chess.cols-1; i--, j++) {
if (Chess.chess[i][j] == 0)
break;
if (Chess.chess[i][j] == Chess.chess[x][y]) {
r = i;
s = j;
break;
}
}
if (r != -2 && s != -2 && Chess.chess[x - 1][y + 1] != Chess.chess[i][j]) {
return new int[] { r, s };
}
else
return null;
}
/* 向右检测是否有相同颜色棋子，如果有且不相邻，改变中间棋子颜色，否则返回NULL */
public int[] hengYou1(int x, int y) {
int r = -2;
int i;
// 向右
for (i = x + 1; i < Chess.cols-1; i++) {
if (Chess.chess[i][y] != 1 && Chess.chess[i][y] != -1)
break;
if (Chess.chess[i][y] == Chess.chess[x][y]) {
r = i;
break;
}
}
if (r != -2 && Chess.chess[x + 1][y] != Chess.chess[i][y]) {
// 改变中间的子
paintChess(x, y, r, y);
return new int[] { r, y };
}
else
return null;
}
/* 向左检测是否有相同颜色棋子，如果有且不相邻，改变中间棋子颜色，否则返回NULL */
public int[] hengZuo1(int x, int y) {
int r = -2;
int i;
// 向左
for (i = x - 1; i >= 0; i--) {
if (Chess.chess[i][y] != 1 && Chess.chess[i][y] != -1)
break;
if (Chess.chess[i][y] == Chess.chess[x][y]) {
r = i;
break;
}
}
if (r != -2 && Chess.chess[x - 1][y] != Chess.chess[i][y]) {
// 改变中间的子
paintChess(x, y, r, y);
return new int[] { r, y };
}
else
return null;
}
/* 斜右上方向 */
public int[] xieyou1(int x, int y) {
// 向上
int r = -2, s = -2;
int i, j;
for (i = x + 1, j = y - 1; i < Chess.rows-1 && j >= 0; i++, j--) {
if (Chess.chess[i][j] == 0)
break;
if (Chess.chess[i][j] == Chess.chess[x][y]) {
r = i;
s = j;
break;
}
}
if (r != -2 && s != -2 && Chess.chess[x + 1][y - 1] != Chess.chess[i][j]) {
// 改变中间的子
paintChess1(x, y, i, j);
return new int[] { r, s };
}
else
return null;
}
/* 斜右下方向 */
public int[] xieyou2(int x, int y) {
// 向下
int r = -2, s = -2;
int i, j;
for (i = x + 1, j = y + 1; i < Chess.rows-1 && j < Chess.cols-1; i++, j++) {
if (Chess.chess[i][j] == 0)
break;
if (Chess.chess[i][j] == Chess.chess[x][y]) {
r = i;
s = j;
break;
}
}
if (r != -2 && s != -2 && Chess.chess[x + 1][y + 1] != Chess.chess[i][j]) {
// 改变中间的子
paintChess2(x, y, i, j);
return new int[] { r, s };
}
else
return null;
}
/* 斜左上方向 */
public int[] xiezuo1(int x, int y) {
// 向上
int r = -2, s = -2;
int i, j;
for (i = x - 1, j = y - 1; i >= 0 && j >= 0; i--, j--) {
if (Chess.chess[i][j] == 0)
break;
if (Chess.chess[i][j] == Chess.chess[x][y]) {
r = i;
s = j;
break;
}
}
if (r != -2 && s != -2 && Chess.chess[x - 1][y - 1] != Chess.chess[i][j]) {
// 改变中间的子
paintChess3(x, y, i, j);
return new int[] { r, s };
}
else
return null;
}
/* 斜左下方向 */
public int[] xiezuo2(int x, int y) {
// 向下
int r = -2, s = -2;
int i, j;
for (i = x - 1, j = y + 1; i >= 0 && j < Chess.cols-1; i--, j++) {
if (Chess.chess[i][j] == 0)
break;
if (Chess.chess[i][j] == Chess.chess[x][y]) {
r = i;
s = j;
break;
}
}
if (r != -2 && s != -2 && Chess.chess[x - 1][y + 1] != Chess.chess[i][j]) {
// 改变中间的子
paintChess4(x, y, i, j);
return new int[] { r, s };
}
else
return null;
}
}
结果截图：
三、实验体会
这次实验内容比较复杂，做起来花了较长的时间。
前半部分是自己实验，学习敏捷开发与XP、编码标准、版本控制和重构。这些知识中比较难的是使用版本控制中的git功能，刚开始根据指导步骤实践时在vim中遇到困难，编写好代码后无法切回命令行界面，后来询问同学，了解到步骤是先按ESC键，再输入：wq，调试过后可以顺利进行后面的实验。其次，学习到最重要的思想---重构。重构包含各个方面，从简单的改变变量名称到较复杂的封装，使我感受到运用好重构可以大大提升我们编写代码的质量，而在接下来编写的小游戏中，我也通过运用这种思想优化了代码。
后半部分是编写一个java小游戏，由于自己的编程能力有限，因此我从网上克隆了一份关于黑白棋的代码。找到代码后，我和伙伴先是一起分析这个代码中语句的功能，并根据TDD的思想，编写测试代码。然后，再进行重构，包括改变变量的名称、将方法进行封装等，尽量使代码简化高效。然而，这并不是一件易事，也让我意识到自己的编程能力还需要很大的提升。
这次实验，我最大的收获是学会使用git功能和建立了重构的思想，这对我以后的java学习会有很大帮助。
附：
|
步骤 |
耗时 |
百分比 |
|
需求分析 |
0.5h |
5% |
|
设计 |
1.5h |
15% |
|
代码实现 |
5h |
50% |
|
测试 |
2h |
20% |
|
分析总结 |
1h |
10% |