java实验三

一、 实验内容

（一）敏捷开发与XP

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

2.极限编程(eXtreme Programming，XP)是一种全新而快捷的软件开发方法。

要点： 1. XP软件开发的基石是XP的活动，包括：编码、测试、倾听、设计。

2. 我们关注其中的编码标准，结对编程，代码集体所有，测试，重构等实践。（如实验二中的TDD）

（二）编码标准

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

学习：

1. 软件辅助修改：在eclipse中，用source->Format进行格式规范；

2. 自己命名：包名全部小写，如： io ；类名第一个字母要大写，如：HelloWorldApp；等

（三）结对编程

内容：在结对编程模式下，一对程序员肩并肩、平等地、互补地进行开发工作。其中的角色分配为驾驶员（控制键盘输入），领航人（起到领航、提醒作用）。

（四）版本控制

摘要：版本控制提供项目级的 undo（撤销） 功能；• 版本控制允许多人在同一代码上工作；• 版本控制系统保存了过去所作的修改的历史记录；具体步骤如下——

# 添加修改文件

$ git add 所有修改的文件

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

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

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

$ git push

学习：由于实验楼无法进入，请求下一次在完成。

（五）重构

摘要：重构(Refactor)，就是在不改变软件外部行为的基础上，改变软件内部的结构，使其更加易于阅读、易于维护和易于变更 。学习：尝试Encapsulate Field（封装）功能：



此外，在重构代码后，还有一个必不可少的步骤即进行新一轮的测试，即产品代码仍要通过之前的所有测试。

（六）实践项目

（队友20135221黄卫的博客：http://www.cnblogs.com/hw00332012/）

1.综述

由于我们小组之前没有编写过具有独立功能和可操作图形化界面程序。因而我们采取“先学习，后操作；边操作，边变通”的实验思路。具体方法是：研读要求—学习代码要素—复习TDD内容—构建测试程序—检查测试程序—测试产品代码—修改产品代码—重新检查产品代码—完成实验报告。在这一过程中，我们对各方面内容都进行了详细记录（未在实验楼中进行托管和git）

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

20135221黄卫：将java代码进行必要注释

20135238龚睿：负责前期学习的整理工作，负责中期的测试代码开发，并对TDD内容进行补充，进行后期测试；

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

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

TDD的一般步骤如下：

明确当前要完成的功能，记录成一个测试列表

快速完成编写针对此功能的测试用例

测试代码编译不通过（没产品代码呢）

编写产品代码

测试通过

对代码进行重构，并保证测试通过（重构下次实验练习）

循环完成所有功能的开发

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

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

4.补充学习内容

Java语句（具体见程序注释）

设计思路（20135238，20135221）

首先，根据用户需求合理分配代码密度，即：

用户直接操作（点击运行）的程序为主控程序，仅包含对与用户接触的窗口的定义语句和相关函数调用；

后台处理图形化界面的语句组成控制程序，包括：方块的形状和位置显示和移动算法、对象位置记录、暂停键及停止条件函数等。

其次，对具体程序进行编写：

MainClass函数：继承JFrame类，调用ERS_Block类；定义窗口大小和位置

ControlSnake函数：继承JPanel类；定义贪吃蛇的坐标位置和果实坐标位置，定义随机数发生器等；建立主函数接收键盘传入并转换成keyCode,执行对应操作；建立Paint函数构造窗口；建立Action函数进行动画演示（包括调用随机数发生函数产生伪随机序列，确定果实位置）

进行代码注释（20135221）

package com.hiyo.app.game;

import java.awt.Button;

import java.awt.Canvas;

import java.awt.Color;

import java.awt.Dimension;

import java.awt.Frame;

import java.awt.Graphics;

import java.awt.GridLayout;

import java.awt.Insets;

import java.awt.Label;

import java.awt.Panel;

import java.awt.TextField;

import java.awt.event.ActionEvent;

import java.awt.event.ActionListener;

import java.awt.event.KeyEvent;

import java.awt.event.KeyListener;

import java.awt.event.WindowAdapter;

import java.awt.event.WindowEvent;

import java.awt.event.WindowListener;

//俄罗斯方块类

public class ERS_Block extends Frame {

public static boolean isPlay = false;

public static int level = 1, score = 0;

public static TextField scoreField, levelField;

public static MyTimer timer;

GameCanvas gameScr;

public static void main(String[] argus) {

ERS_Block ers = new ERS_Block(

"俄罗斯方块游戏 V1.0 Author:KG35");

WindowListener win_listener = new WinListener();

ers.addWindowListener(win_listener);

}

// 俄罗斯方块类的构造方法

ERS_Block(String title) {

super(title);

setSize(600, 480);

setLayout(new GridLayout(1, 2));

gameScr = new GameCanvas();

gameScr.addKeyListener(gameScr);

timer = new MyTimer(gameScr);

timer.setDaemon(true);

timer.start();

timer.suspend();

add(gameScr);

Panel rightScr = new Panel();

rightScr.setLayout(new GridLayout(2, 1, 0, 30));

rightScr.setSize(120, 500);

add(rightScr);

// 右边信息窗体的布局

MyPanel infoScr = new MyPanel();

infoScr.setLayout(new GridLayout(4, 1, 0, 5));

infoScr.setSize(120, 300);

rightScr.add(infoScr);

// 定义标签和初始值

Label scorep = new Label("分数:", Label.LEFT);

Label levelp = new Label("级数:", Label.LEFT);

scoreField = new TextField(8);

levelField = new TextField(8);

scoreField.setEditable(false);

levelField.setEditable(false);

infoScr.add(scorep);

infoScr.add(scoreField);

infoScr.add(levelp);

infoScr.add(levelField);

scorep.setSize(new Dimension(20, 60));

scoreField.setSize(new Dimension(20, 60));

levelp.setSize(new Dimension(20, 60));

levelField.setSize(new Dimension(20, 60));

scoreField.setText("0");

levelField.setText("1");

// 右边控制按钮窗体的布局

MyPanel controlScr = new MyPanel();

controlScr.setLayout(new GridLayout(5, 1, 0, 5));

rightScr.add(controlScr);

// 定义按钮play

Button play_b = new Button("开始游戏");

play_b.setSize(new Dimension(50, 200));

play_b.addActionListener(new Command(Command.button_play, gameScr));

// 定义按钮Level UP

Button level_up_b = new Button("提高级数");

level_up_b.setSize(new Dimension(50, 200));

level_up_b.addActionListener(new Command(Command.button_levelup,

gameScr));

// 定义按钮Level Down

Button level_down_b = new Button("降低级数");

level_down_b.setSize(new Dimension(50, 200));

level_down_b.addActionListener(new Command(Command.button_leveldown,

gameScr));

// 定义按钮Level Pause

Button pause_b = new Button("游戏暂停");

pause_b.setSize(new Dimension(50, 200));

pause_b.addActionListener(new Command(Command.button_pause, gameScr));

// 定义按钮Quit

Button quit_b = new Button("退出游戏");

quit_b.setSize(new Dimension(50, 200));

quit_b.addActionListener(new Command(Command.button_quit, gameScr));

controlScr.add(play_b);

controlScr.add(level_up_b);

controlScr.add(level_down_b);

controlScr.add(pause_b);

controlScr.add(quit_b);

setVisible(true);

gameScr.requestFocus();

}

}

// 重写MyPanel类，使Panel的四周留空间

class MyPanel extends Panel {

public Insets getInsets() {

return new Insets(30, 50, 30, 50);

}

}

// 游戏画布类

class GameCanvas extends Canvas implements KeyListener {

final int unitSize = 30; // 小方块边长

int rowNum; // 正方格的行数

int columnNum; // 正方格的列数

int maxAllowRowNum; // 允许有多少行未削

int blockInitRow; // 新出现块的起始行坐标

int blockInitCol; // 新出现块的起始列坐标

int[][] scrArr; // 屏幕数组

Block b; // 对方快的引用

// 画布类的构造方法

GameCanvas() {

rowNum = 15;

columnNum = 10;

maxAllowRowNum = rowNum - 2;

b = new Block(this);

blockInitRow = rowNum - 1;

blockInitCol = columnNum / 2 - 2;

scrArr = new int[32][32];

}

// 初始化屏幕，并将屏幕数组清零的方法

void initScr() {

for (int i = 0; i < rowNum; i++)

for (int j = 0; j < columnNum; j++)

scrArr[i][j] = 0;

b.reset();

repaint();

}

// 重新刷新画布方法

public void paint(Graphics g) {

for (int i = 0; i < rowNum; i++)

for (int j = 0; j < columnNum; j++)

drawUnit(i, j, scrArr[i][j]);

}

// 画方块的方法

public void drawUnit(int row, int col, int type) {

scrArr[row][col] = type;

Graphics g = getGraphics();

switch (type) { // 表示画方快的方法

case 0:

g.setColor(Color.black);

break; // 以背景为颜色画

case 1:

g.setColor(Color.blue);

break; // 画正在下落的方块

case 2:

g.setColor(Color.magenta);

break; // 画已经落下的方法

}

g.fill3DRect(col * unitSize, getSize().height - (row + 1) * unitSize,

unitSize, unitSize, true);

g.dispose();

}

public Block getBlock() {

return b; // 返回block实例的引用

}

// 返回屏幕数组中(row,col)位置的属性值

public int getScrArrXY(int row, int col) {

if (row < 0 || row >= rowNum || col < 0 || col >= columnNum)

return (-1);

else

return (scrArr[row][col]);

}

// 返回新块的初始行坐标方法

public int getInitRow() {

return (blockInitRow); // 返回新块的初始行坐标

}

// 返回新块的初始列坐标方法

public int getInitCol() {

return (blockInitCol); // 返回新块的初始列坐标

}

// 满行删除方法

void deleteFullLine() {

int full_line_num = 0;

int k = 0;

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

boolean isfull = true;

L1: for (int j = 0; j < columnNum; j++)

if (scrArr[i][j] == 0) {

k++;

isfull = false;

break L1;

}

if (isfull)

full_line_num++;

if (k != 0 && k - 1 != i && !isfull)

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

if (scrArr[i][j] == 0)

drawUnit(k - 1, j, 0);

else

drawUnit(k - 1, j, 2);

scrArr[k - 1][j] = scrArr[i][j];

}

}

for (int i = k - 1; i < rowNum; i++) {

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

drawUnit(i, j, 0);

scrArr[i][j] = 0;

}

}

ERS_Block.score += full_line_num;

ERS_Block.scoreField.setText("" + ERS_Block.score);

}

// 判断游戏是否结束方法

boolean isGameEnd() {

for (int col = 0; col < columnNum; col++) {

if (scrArr[maxAllowRowNum][col] != 0)

return true;

}

return false;

}

public void keyTyped(KeyEvent e) {

}

public void keyReleased(KeyEvent e) {

}

// 处理键盘输入的方法

public void keyPressed(KeyEvent e) {

if (!ERS_Block.isPlay)

return;

switch (e.getKeyCode()) {

case KeyEvent.VK_DOWN:

b.fallDown();

break;

case KeyEvent.VK_LEFT:

b.leftMove();

break;

case KeyEvent.VK_RIGHT:

b.rightMove();

break;

case KeyEvent.VK_SPACE:

b.leftTurn();

break;

}

}

}

// 处理控制类

class Command implements ActionListener {

static final int button_play = 1; // 给按钮分配编号

static final int button_levelup = 2;

static final int button_leveldown = 3;

static final int button_quit = 4;

static final int button_pause = 5;

static boolean pause_resume = true;

int curButton; // 当前按钮

GameCanvas scr;

// 控制按钮类的构造方法

Command(int button, GameCanvas scr) {

curButton = button;

this.scr = scr;

}

// 按钮执行方法

public void actionPerformed(ActionEvent e) {

switch (curButton) {

case button_play:

if (!ERS_Block.isPlay) {

scr.initScr();

ERS_Block.isPlay = true;

ERS_Block.score = 0;

ERS_Block.scoreField.setText("0");

ERS_Block.timer.resume();

}

scr.requestFocus();

break;

case button_levelup:

if (ERS_Block.level < 10) {

ERS_Block.level++;

ERS_Block.levelField.setText("" + ERS_Block.level);

ERS_Block.score = 0;

ERS_Block.scoreField.setText("" + ERS_Block.score);

}

scr.requestFocus();

break;

case button_leveldown:

if (ERS_Block.level > 1) {

ERS_Block.level--;

ERS_Block.levelField.setText("" + ERS_Block.level);

ERS_Block.score = 0;

ERS_Block.scoreField.setText("" + ERS_Block.score);

}

scr.requestFocus();

break;

case button_pause:

if (pause_resume) {

ERS_Block.timer.suspend();

pause_resume = false;

} else {

ERS_Block.timer.resume();

pause_resume = true;

}

scr.requestFocus();

break;

case button_quit:

System.exit(0);

}

}

}

// 方块类

class Block {

static int[][] pattern = {

{ 0x0f00, 0x4444, 0x0f00, 0x4444 },// 用十六进至表示，本行表示长条四种状态

{ 0x04e0, 0x0464, 0x00e4, 0x04c4 },

{ 0x4620, 0x6c00, 0x4620, 0x6c00 },

{ 0x2640, 0xc600, 0x2640, 0xc600 },

{ 0x6220, 0x1700, 0x2230, 0x0740 },

{ 0x6440, 0x0e20, 0x44c0, 0x8e00 },

{ 0x0660, 0x0660, 0x0660, 0x0660 } };

int blockType; // 块的模式号（0-6）

int turnState; // 块的翻转状态（0-3）

int blockState; // 快的下落状态

int row, col; // 块在画布上的坐标

GameCanvas scr;

// 块类的构造方法

Block(GameCanvas scr) {

this.scr = scr;

blockType = (int) (Math.random() * 1000) % 7;

turnState = (int) (Math.random() * 1000) % 4;

blockState = 1;

row = scr.getInitRow();

col = scr.getInitCol();

}

// 重新初始化块，并显示新块

public void reset() {

blockType = (int) (Math.random() * 1000) % 7;

turnState = (int) (Math.random() * 1000) % 4;

blockState = 1;

row = scr.getInitRow();

col = scr.getInitCol();

dispBlock(1);

}

// 实现“块”翻转的方法

public void leftTurn() {

if (assertValid(blockType, (turnState + 1) % 4, row, col)) {

dispBlock(0);

turnState = (turnState + 1) % 4;

dispBlock(1);

}

}

// 实现“块”的左移的方法

public void leftMove() {

if (assertValid(blockType, turnState, row, col - 1)) {

dispBlock(0);

col--;

dispBlock(1);

}

}

// 实现块的右移

public void rightMove() {

if (assertValid(blockType, turnState, row, col + 1)) {

dispBlock(0);

col++;

dispBlock(1);

}

}

// 实现块落下的操作的方法

public boolean fallDown() {

if (blockState == 2)

return (false);

if (assertValid(blockType, turnState, row - 1, col)) {

dispBlock(0);

row--;

dispBlock(1);

return (true);

} else {

blockState = 2;

dispBlock(2);

return (false);

}

}

// 判断是否正确的方法

boolean assertValid(int t, int s, int row, int col) {

int k = 0x8000;

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

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

if ((int) (pattern[t][s] & k) != 0) {

int temp = scr.getScrArrXY(row - i, col + j);

if (temp < 0 || temp == 2)

return false;

}

k = k >> 1;

}

}

return true;

}

// 同步显示的方法

public synchronized void dispBlock(int s) {

int k = 0x8000;

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

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

if (((int) pattern[blockType][turnState] & k) != 0) {

scr.drawUnit(row - i, col + j, s);

}

k = k >> 1;

}

}

}

}

// 定时线程

class MyTimer extends Thread {

GameCanvas scr;

public MyTimer(GameCanvas scr) {

this.scr = scr;

}

public void run() {

while (true) {

try {

sleep((10 - ERS_Block.level + 1) * 100);

} catch (InterruptedException e) {

}

if (!scr.getBlock().fallDown()) {

scr.deleteFullLine();

if (scr.isGameEnd()) {

ERS_Block.isPlay = false;

suspend();

} else

scr.getBlock().reset();

}

}

}

}

class WinListener extends WindowAdapter {

public void windowClosing(WindowEvent l) {

System.exit(0);

}

}

4. 代码测试及思路（20135238）

测试出现了问题还在解决中= 。= 问题如图，



5. 过程记录（20135238）



6.时间统计

因为网络问题实验楼上的任务占用了太多时间，浪费了大量的精力但是还没有做成。。。所以还是迫切的希望实验楼能够正常出入=。=

　　在实践部分，调试研究方块代码消耗了不少的时间，但是也是最能体现本次实验的精髓之处，相比之下在实验楼的登录问题上花费的时间就相当可惜了。

7.实验感悟

本次实验，通过对实验五、六部分地学习与研究，让我对Eclipse的功能进一步了解，并且加深了代码差错的修改能力（四百多行啊！！）。

并且我留下了这次实践的代码，决定收藏好这编程路上的精彩瞬间。