JAVA OOP DAY02
1 重载drop方法，moveLeft方法
1.1 问题
前面的案例中，已经实现了格子下落一行以及左移多列的功能，本案例需要扩展下落和左移功能，详细要求如下：
1． 调用 moveLeft 方法，不用传入参数，格子即左移一列，效果如图－1中的中图所示；
2． 调用 drop 方法，传入下落的行数后，格子可以下落多行，效果如图－1中的右图所示。
图－1
1.2 方案
Cell 类已经定义了不带参数的 drop 方法，实现下落一行的功能。如果需要能下落多列，则需要实现该方法的重载：定义带有参数的 drop 方法，代码如下所示：
public void drop(int d) {
row += d;
}
Cell 类中已经定义的 moveLeft 方法，带有int类型的参数，实现左移多列的功能。现需要调用该方法时不用传递参数，也能左移一列，则需要实现该方法的重载：定义不带参数的 moveLeft 方法。代码如下所示：
public void moveLeft() {
col--;
}
1.3 步骤
实现此案例需要按照如下步骤进行。
步骤一：为 Cell 类定义重载的 drop 方法
在Cell 类中，重载drop方法，定义带有参数的 drop 方法，实现下落多列的功能。代码如下所示：
public class Cell {
int row;
int col;
//下落一行
public void drop() {
row++;
}
//左移
public void moveLeft(int d) {
col -= d;
}
public String getCellInfo() {
return row + "," + col;
}
#cold_bold//重载的 drop 方法
#cold_bold public void drop(int d) {
#cold_bold row += d;
#cold_bold }
}
步骤二：为 Cell 类定义重载的 moveLeft 方法
在Cell 类中，重载moveLeft方法，定义不带参数的 moveLeft 方法，实现左移一列的功能。代码如下所示：
public class Cell {
int row;
int col;
//下落一行
public void drop() {
row++;
}
//左移
public void moveLeft(int d) {
col -= d;
}
public String getCellInfo() {
return row + "," + col;
}
//重载的 drop 方法
public void drop(int d) {
row += d;
}
#cold_bold//重载的 moveLeft方法
#cold_bold public void moveLeft() {
#cold_bold col--;
#cold_bold }
}
步骤三：测试
在CellGame 类的main 方法中添加代码：创建坐标为（15,6）的格子，打印信息；然后调用cell 对象的 moveLeft方法，实现格子左移一列；并调用 Cell 对象的drop方法，实现格子下落一定的行数，并打印信息。代码如下所示：
import java.util.Scanner;
public class CellGame{
public static void main(String[] args) {
#cold_bold System.out.println("----------绘制Cell----------");
#cold_bold //创建 Cell对象，并打印
#cold_bold Cell cell = new Cell();
#cold_bold cell.row = 15;
#cold_bold cell.col = 6;
#cold_bold printCell(cell);
#cold_bold
#cold_bold //左移
#cold_bold System.out.println("----------Cell左移一列----------");
#cold_bold cell.moveLeft();
#cold_bold printCell(cell);
#cold_bold
#cold_bold //下落
#cold_bold System.out.println("----------Cell下落----------");
#cold_bold System.out.print("请输入下落的行数：");
#cold_bold Scanner scan = new Scanner(System.in);
#cold_bold int rows = scan.nextInt();
#cold_bold scan.close();
#cold_bold cell.drop(rows);
#cold_bold printCell(cell);
}
public static void printCell(Cell cell) {
int totalRow = 20;
int totalCol = 10;
// 打印格子的位置信息
System.out.println("Cell的位置为：(" + cell.getCellInfo() + ")");
//打印场地
for (int row = 0; row < totalRow; row++) {
for (int col = 0; col < totalCol; col++) {
if (cell.row == row && cell.col == col) {
//打印指定的格子
System.out.print("* ");
} else {
System.out.print("- ");
}
}
System.out.println();
}
}
}
注意：此步骤中，需要导入java.util包下的Scanner类。
1.4 完整代码
本案例中，类Cell 的完整代码如下所示：
public class Cell {
int row;
int col;
//下落一行
public void drop() {
row++;
}
//左移
public void moveLeft(int d) {
col -= d;
}
public String getCellInfo() {
return row + "," + col;
}
//重载的 drop 方法
public void drop(int d) {
row += d;
}
//重载的 moveLeft方法
public void moveLeft() {
col--;
}
}
类CellGame的完整代码如下所示：
import java.util.Scanner;
public class CellGame{
public static void main(String[] args) {
System.out.println("----------绘制Cell----------");
//创建 Cell对象，并打印
Cell cell = new Cell();
cell.row = 15;
cell.col = 6;
printCell(cell);
//左移
System.out.println("----------Cell左移一列----------");
cell.moveLeft();
printCell(cell);
//下落
System.out.println("----------Cell下落----------");
System.out.print("请输入下落的行数：");
Scanner scan = new Scanner(System.in);
int rows = scan.nextInt();
scan.close();
cell.drop(rows);
printCell(cell);
}
public static void printCell(Cell cell) {
int totalRow = 20;
int totalCol = 10;
// 打印格子的位置信息
System.out.println("Cell的位置为：(" + cell.getCellInfo() + ")");
//打印场地
for (int row = 0; row < totalRow; row++) {
for (int col = 0; col < totalCol; col++) {
if (cell.row == row && cell.col == col) {
//打印指定的格子
System.out.print("* ");
} else {
System.out.print("- ");
}
}
System.out.println();
}
}
}
2 给Cell类添加构造方法
2.1 问题
为 Cell 类定义有参构造方法，并在构造方法中初始化 Cell 的行和列；然后创建一个坐标为（0,4）的格子，并打印信息，效果如图－2所示：
图－2
图－2中蓝色圈中的“*”号表示所创建的格子。
2.2 方案
在方法中可以通过this关键字表示 “调用该方法的那个对象”，因此，可以使用this关键字指向类中的成员变量，代码如下所示：
/**
* 使用 this 关键字重构
* @param row：行
* @param col：列
*/
public Cell(int row, int col) {
this.row = row;
this.col = col;
}
2.3 步骤
实现此案例需要按照如下步骤进行。
步骤一：给Cell 类添加构造方法
在Cell 类中，添加带两个参数的构造方法，代码如下所示：
public class Cell {
int row;
int col;
#cold_bold /**
#cold_bold * 使用 this 关键字重构
#cold_bold * @param row：行
#cold_bold * @param col：列
#cold_bold */
#cold_bold public Cell(int row, int col) {
#cold_bold this.row = row;
#cold_bold this.col = col;
#cold_bold }
#cold_bold
//下落一行
public void drop() {
row++;
}
//左移
public void moveLeft(int d) {
col -= d;
}
public String getCellInfo() {
return row + "," + col;
}
//重载的 drop 方法
public void drop(int d) {
row += d;
}
//重载的 moveLeft方法
public void moveLeft() {
col--;
}
}
步骤二：测试有参构造方法
在CellGame 类的main 方法中添加代码：使用构造方法创建坐标为（0,4）的格子，并打印信息，代码如下所示：
public class CellGame{
public static void main(String[] args) {
#cold_bold System.out.println("----------绘制Cell----------");
#cold_bold //创建 Cell对象，并打印
#cold_bold Cell cell2 = new Cell(0, 4);
#cold_bold printCell(cell2);
}
public static void printCell(Cell cell) {
int totalRow = 20;
int totalCol = 10;
// 打印格子的位置信息
System.out.println("Cell的位置为：(" + cell.getCellInfo() + ")");
//打印场地
for (int row = 0; row < totalRow; row++) {
for (int col = 0; col < totalCol; col++) {
if (cell.row == row && cell.col == col) {
//打印指定的格子
System.out.print("* ");
} else {
System.out.print("- ");
}
}
System.out.println();
}
}
}
2.4 完整代码
本案例中，类Cell 的完整代码如下所示：
public class Cell {
int row;
int col;
/**
* 使用 this 关键字重构
* @param row：行
* @param col：列
*/
public Cell(int row, int col) {
this.row = row;
this.col = col;
}
//下落一行
public void drop() {
row++;
}
//左移
public void moveLeft(int d) {
col -= d;
}
public String getCellInfo() {
return row + "," + col;
}
//重载的 drop 方法
public void drop(int d) {
row += d;
}
//重载的 moveLeft方法
public void moveLeft() {
col--;
}
}
类CellGame的完整代码如下所示：
public class CellGame{
public static void main(String[] args) {
System.out.println("----------绘制Cell----------");
//创建 Cell对象，并打印
//Cell cell2 = new Cell(0, 4);
//printCell(cell2);
}
public static void printCell(Cell cell) {
int totalRow = 20;
int totalCol = 10;
// 打印格子的位置信息
System.out.println("Cell的位置为：(" + cell.getCellInfo() + ")");
//打印场地
for (int row = 0; row < totalRow; row++) {
for (int col = 0; col < totalCol; col++) {
if (cell.row == row && cell.col == col) {
//打印指定的格子
System.out.print("* ");
} else {
System.out.print("- ");
}
}
System.out.println();
}
}
}
3 给Cell类添加重载的构造方法
3.1 问题
给Cell类添加重载的构造方法，详细要求如下：
1. 为 Cell 类定义默认构造方法，使用该构造方法创建对象，并打印显示。
2. 继续为 Cell 类定义构造方法，要求该构造方法接收一个 Cell 类型的参数。使用该构造方法，创建一个位置为（0,4）的格子，并打印显示。
3.2 方案
可以对一个类定义多个构造方法，这些构造方法都有相同的名称（类名），但是参数不同，称之为构造方法的重载。在创建对象时，Java编译器会根据不同的参数调用不同的构造方法。
我们已经为 Cell 类定义了带有两个参数的构造方法，这样，就可以使用如下代码创建 Cell对象：
Cell cell2 = new Cell(0, 4); //row为0，col为4
但是，此时，就不能再用如下的方式创建 Cell 对象了：
Cell cell2 = new Cell();
这是因为，当我们为类定义了构造方法后，Java编译器将不再为该类添加默认的构造方法。如果依然希望能够使用默认的方式来创建对象，则需要为类重新定义默认的构造方法，代码如下所示：
public Cell() {
}
在默认构造方法中，依然需要为成员变量 col 和 row 赋值，则可以使用如下代码：
public Cell() {
this(0, 0);
}
我们可以继续为 Cell 类定义带有其他类型参数的构造方法，代码如下所示：
public Cell(Cell cell) {
this(cell.row, cell.col);
}
然后，可以使用如下的方式创建 Cell 对象：
Cell cell1 = new Cell(0,4); Cell cell2 = new Cell(cell1);
当我们为类定义了多个构造方法后，在实际使用时，可以根据实际情况选择合适的构造方法。
3.3 步骤
实现此案例需要按照如下步骤进行。
步骤一：为 Cell 类添加默认构造方法
在Cell 类中，定义默认构造方法。代码如下所示：
public class Cell {
int row;
int col;
/**
* 使用 this 关键字重构
* @param row：行
* @param col：列
*/
public Cell(int row, int col) {
this.row = row;
this.col = col;
}
/**
* 默认构造方法
*/
public Cell() {
this(0, 0);
}
//其他方法的代码
//...
}
步骤二：测试默认构造方法
修改CellGame 类的main 方法，使用默认构造方法创建 Cell 对象，并进行打印测试，代码如下所示：
public static void main(String[] args) {
System.out.println("----------绘制Cell----------");
#cold_bold //创建 Cell对象，并打印
#cold_bold Cell cell2 = new Cell();
printCell(cell2);
}
步骤三：再为 Cell 类添加一个构造方法
在Cell 类中，定义接收 Cell 类型参数的构造方法。代码如下所示：
public class Cell {
int row;
int col;
/**
* 使用 this 关键字重构
* @param row：行
* @param col：列
*/
public Cell(int row, int col) {
this.row = row;
this.col = col;
}
/**
* 默认构造方法
*/
public Cell() {
this(0, 0);
}
#cold_bold /**
#cold_bold * 构造方法的重载
#cold_bold * @param cell
#cold_bold */
#cold_bold public Cell(Cell cell) {
#cold_bold this(cell.row, cell.col);
#cold_bold }
//其他方法的代码
//...
}
步骤四：测试Cell类型参数的构造方法
修改CellGame 类的main 方法，使用新添加的构造方法创建 Cell 对象，并进行打印测试，代码如下所示：
public static void main(String[] args) {
System.out.println("----------绘制Cell----------");
//创建 Cell对象，并打印
//Cell cell2 = new Cell();
//printCell(cell2);
#cold_bold //创建 Cell对象，并打印
#cold_bold Cell cell1 = new Cell(0,4);
#cold_bold Cell cell2 = new Cell(cell1);
#cold_bold printCell(cell2);
}
3.4 完整代码
本案例中，类Cell 的完整代码如下所示：
public class Cell {
int row;
int col;
/**
* 使用 this 关键字重构
* @param row：行
* @param col：列
*/
public Cell(int row, int col) {
this.row = row;
this.col = col;
}
/**
* 默认构造方法
*/
public Cell() {
this(0, 0);
}
/**
* 构造方法的重载
* @param cell
*/
public Cell(Cell cell) {
this(cell.row, cell.col);
}
//下落一行
public void drop() {
row++;
}
//左移
public void moveLeft(int d) {
col -= d;
}
public String getCellInfo() {
return row + "," + col;
}
//重载的 drop 方法
public void drop(int d) {
row += d;
}
//重载的 moveLeft方法
public void moveLeft() {
col--;
}
}
类CellGame的完整代码如下所示：
public class CellGame{
public static void main(String[] args) {
System.out.println("----------绘制Cell----------");
//创建 Cell对象，并打印
//Cell cell2 = new Cell();
//printCell(cell2);
//创建 Cell对象，并打印
Cell cell1 = new Cell(0,4);
Cell cell2 = new Cell(cell1);
printCell(cell2);
}
public static void printCell(Cell cell) {
int totalRow = 20;
int totalCol = 10;
// 打印格子的位置信息
System.out.println("Cell的位置为：(" + cell.getCellInfo() + ")");
//打印场地
for (int row = 0; row < totalRow; row++) {
for (int col = 0; col < totalCol; col++) {
if (cell.row == row && cell.col == col) {
//打印指定的格子
System.out.print("* ");
} else {
System.out.print("- ");
}
}
System.out.println();
}
}
}
4 定义Tetris项目中的T类和J类并测试
4.1 问题
在Tetris游戏中，游戏场地由10列×20行个正方形格子构成，如图-3所示，每个方块由四个格子组成，绘制在场地中，如图-3所示中的红色方块。
图- 3
4个小型正方形格子组成的规则图形（Tetromino），共有7种，分别以S、Z、L、J、I、O、T这7个字母的形状来命名，各个图形形状如图-4所示。
图- 4
之前案例中定义的Cell类，表示游戏场地中的一个正方形格子，存储其在场地中的位置。本案例中会使用到Cell类，拷贝之前案例中的该类使用即可。本案例要求定义表示T型方块的类T和J型方块的类J。T型方块和J型方块的形状如图-4所示中黄色方块和紫色方块。
4.2 方案
要实现本案例要求的功能，解决方案如下：
1. 定义名为T的类，由于每个方块有四个格子，因此，在T类中添加属性cells，cells属性的类型为Cell数组类型，即，Cell[]。这样，cells数组中就可以存储四个格子来表示一个方块。
2. 为T类添加构造方法。可以提供无参数构造方法，及按顺时针方向、方块中第一个格子的行和列作为参数的构造方法。
3. 为了方便查看方块中四个格子的坐标，因此，定义print方法，实现按顺时针方向，打印方块中四个格子所在的坐标,并对print进行测试。
4. 每个方块都可以下落，左移和右移，因此，在T类中，定义drop方法实现方块下落；定义moveLeft方法实现方块左移；定义moveRight方法实现方块左移,并对这三个方法进行测试。
5. 实现J类。J类的实现和T类是类似的，主要注意，在构造方法中，按照J型进行初始化cells属性,并进行测试。
4.3 步骤
实现此案例需要按照如下步骤进行。
步骤一：定义T类
首先定义一个名为 T的类，代码如下所示：
public class T {
}
步骤二：定义属性
由于每个方块有四个格子，因此，在类 T中定义一个名为cells的属性，cells属性的类型为Cell数组类型，即，Cell[]。代码如下所示：
public class T {
#cold_bold Cell[] cells;
}
步骤三：定义构造方法
首先，在T类中添加第一个格子的行和列作为参数的构造方法，并在构造方法按顺时针方向初始化T型方块。
图- 5
从图-5中，按顺时针方向查看T型方块，可以看出，第一个格子的行列坐标是（0，1），第二个格子的行列坐标是（0，2），第三个格子的行列坐标是（0，3），第四个格子的行列坐标是（1，2）。假设把第一个格子的行列坐标用(row，col)来表示，那么,第二个格子的行列坐标为(row,col+1), 第三个格子的行列坐标为(row,col+2), 第四个格子的行列坐标为(row+1,col+1),这样，T型方块就可以用传入的参数对cells属性进行初始了。代码如下所示:
public class T {
Cell[] cells;
#cold_bold /**
#cold_bold * 构造方法，为属性cells进行初始化
#cold_bold *
#cold_bold * @param row顺时针方向
#cold_bold * ，第一个坐标的行
#cold_bold * @param col顺时针方向
#cold_bold * ，第一个坐标的列
#cold_bold */
#cold_bold public T(int row, int col) {
#cold_bold cells = new Cell[4];
#cold_bold // 按顺时针方向初始化Cell
#cold_bold cells[0] = new Cell(row, col);
#cold_bold cells[1] = new Cell(row, col + 1);
#cold_bold cells[2] = new Cell(row, col + 2);
#cold_bold cells[3] = new Cell(row + 1, col + 1);
#cold_bold }
}
在T类中添加无参数构造方法，在该构造方法中，使用this关键字调用参数为T(int row, int col)的构造方法，并设置方块的顺时针方向的第一个格子的行和列为（0，0），代码如下所示：
public class T {
Cell[] cells;// 属性,用来存储一个方块的四个格子的坐标
#cold_bold /**
#cold_bold * 构造方法，为属性cells进行初始化
#cold_bold */
#cold_bold public T() {
#cold_bold this(0, 0);
#cold_bold }
/**
* 构造方法，为属性cells进行初始化
*
* @param row
* 顺时针方向 ，第一个坐标的行
* @param col
* 顺时针方向 ，第一个坐标的列
*/
public T(int row, int col) {
cells = new Cell[4];
// 按顺时针方向初始化Cell
cells[0] = new Cell(row, col);
cells[1] = new Cell(row, col + 1);
cells[2] = new Cell(row, col + 2);
cells[3] = new Cell(row + 1, col + 1);
}
}
步骤四：定义打印方法
为了方便查看方块中四个格子的坐标，因此，定义print方法。在print方法中，按顺时针方向，打印方块中四个格子所在的坐标。实现此功能，循环遍历cells数组即可。代码如下所示：
public class T {
Cell[] cells;// 属性,用来存储一个方块的四个格子的坐标
/**
* 构造方法，为属性cells进行初始化
*/
public T() {
this(0, 0);
}
/**
* 构造方法，为属性cells进行初始化
*
* @param row
* 顺时针方向 ，第一个坐标的行
* @param col
* 顺时针方向 ，第一个坐标的列
*/
public T(int row, int col) {
cells = new Cell[4];
// 按顺时针方向初始化Cell
cells[0] = new Cell(row, col);
cells[1] = new Cell(row, col + 1);
cells[2] = new Cell(row, col + 2);
cells[3] = new Cell(row + 1, col + 1);
}
#cold_bold /**
#cold_bold * 按顺时针方向，打印方块中四个格子所在的坐标
#cold_bold */
#cold_bold public void print() {
#cold_bold String str = "";
#cold_bold for (int i = 0; i < cells.length - 1; i++) {
#cold_bold str += "(" + cells[i].getCellInfo() + "), ";
#cold_bold }
#cold_bold str += "(" + cells[cells.length - 1].getCellInfo() + ")";
#cold_bold System.out.println(str);
#cold_bold
#cold_bold }
}
步骤五：定义方块的下落方法
定义方块的下落的方法，即，在T类中，添加方块下落一个格子的方法。要实现下落一个格子，只需要循环cells属性，将方块中的每一个格子的行加1即可。代码如下所示：
public class T {
Cell[] cells;// 属性,用来存储一个方块的四个格子的坐标
/**
* 构造方法，为属性cells进行初始化
*/
public T() {
this(0, 0);
}
/**
* 构造方法，为属性cells进行初始化
*
* @param row
* 顺时针方向 ，第一个坐标的行
* @param col
* 顺时针方向 ，第一个坐标的列
*/
public T(int row, int col) {
cells = new Cell[4];
// 按顺时针方向初始化Cell
cells[0] = new Cell(row, col);
cells[1] = new Cell(row, col + 1);
cells[2] = new Cell(row, col + 2);
cells[3] = new Cell(row + 1, col + 1);
}
/**
* 按顺时针方向，打印方块中四个格子所在的坐标
*/
public void print() {
String str = "";
for (int i = 0; i < cells.length - 1; i++) {
str += "(" + cells[i].getCellInfo() + "), ";
}
str += "(" + cells[cells.length - 1].getCellInfo() + ")";
System.out.println(str);
}
#cold_bold /**
#cold_bold * 使方块下落一个格子
#cold_bold */
#cold_bold public void drop() {
#cold_bold for (int i = 0; i < cells.length; i++) {
#cold_bold cells[i].row++;
#cold_bold }
#cold_bold }
}
步骤六：定义方块的左移方法
定义方块的左移的方法，即，在T类中，添加方块左移一个格子的方法。要实现方块左移一个格子，只需要循环cells属性，将方块中的每一个格子的列减1即可。代码如下所示：
public class T {
Cell[] cells;// 属性,用来存储一个方块的四个格子的坐标
/**
* 构造方法，为属性cells进行初始化
*/
public T() {
this(0, 0);
}
/**
* 构造方法，为属性cells进行初始化
*
* @param row
* 顺时针方向 ，第一个坐标的行
* @param col
* 顺时针方向 ，第一个坐标的列
*/
public T(int row, int col) {
cells = new Cell[4];
// 按顺时针方向初始化Cell
cells[0] = new Cell(row, col);
cells[1] = new Cell(row, col + 1);
cells[2] = new Cell(row, col + 2);
cells[3] = new Cell(row + 1, col + 1);
}
/**
* 按顺时针方向，打印方块中四个格子所在的坐标
*/
public void print() {
String str = "";
for (int i = 0; i < cells.length - 1; i++) {
str += "(" + cells[i].getCellInfo() + "), ";
}
str += "(" + cells[cells.length - 1].getCellInfo() + ")";
System.out.println(str);
}
/**
* 使方块下落一个格子
*/
public void drop() {
for (int i = 0; i < cells.length; i++) {
cells[i].row++;
}
}
#cold_bold /**
#cold_bold * 使方块左移一个格子
#cold_bold */
#cold_bold public void moveLeft() {
#cold_bold for (int i = 0; i < cells.length; i++) {
#cold_bold cells[i].col--;
#cold_bold }
#cold_bold }
}
步骤七：定义方块的右移方法
定义方块的右移的方法，即，在T类中，添加方块右移一个格子的方法。要实现方块右移一个格子，只需要循环cells属性，将方块中的每一个格子的列加1即可。代码如下所示：
public class T {
Cell[] cells;// 属性,用来存储一个方块的四个格子的坐标
/**
* 构造方法，为属性cells进行初始化
*/
public T() {
this(0, 0);
}
/**
* 构造方法，为属性cells进行初始化
*
* @param row
* 顺时针方向 ，第一个坐标的行
* @param col
* 顺时针方向 ，第一个坐标的列
*/
public T(int row, int col) {
cells = new Cell[4];
// 按顺时针方向初始化Cell
cells[0] = new Cell(row, col);
cells[1] = new Cell(row, col + 1);
cells[2] = new Cell(row, col + 2);
cells[3] = new Cell(row + 1, col + 1);
}
/**
* 按顺时针方向，打印方块中四个格子所在的坐标
*/
public void print() {
String str = "";
for (int i = 0; i < cells.length - 1; i++) {
str += "(" + cells[i].getCellInfo() + "), ";
}
str += "(" + cells[cells.length - 1].getCellInfo() + ")";
System.out.println(str);
}
/**
* 使方块下落一个格子
*/
public void drop() {
for (int i = 0; i < cells.length; i++) {
cells[i].row++;
}
}
/**
* 使方块左移一个格子
*/
public void moveLeft() {
for (int i = 0; i < cells.length; i++) {
cells[i].col--;
}
}
#cold_bold /**
#cold_bold * 使方块右移一个格子
#cold_bold */
#cold_bold public void moveRight() {
#cold_bold for (int i = 0; i < cells.length; i++) {
#cold_bold cells[i].col++;
#cold_bold }
#cold_bold }
}
步骤八：测试方块的右移方法
新建TestT类，在该类中的main方法中，首先，调用对象t的print方法来查看T型方块的原始坐标；然后，调用对象t的moveRight方法；最后，再调用对象t的print方法查看坐标的变化情况，代码如下所示：
public class TestT {
public static void main(String[] args) {
T t=new T(0,1);
//测试print方法
System.out.println("原始坐标为：");
t.print();
//测试drop方法
// t.drop();
// System.out.println("调用drop方法后的坐标：");
// t.print();
//测试moveLeft方法
// t.moveLeft();
// System.out.println("调用moveLeft方法后的坐标：");
// t.print();
#cold_bold //测试moveRight方法
#cold_bold t.moveRight();
#cold_bold System.out.println("调用moveRight方法后的坐标：");
#cold_bold t.print();
}
}
控制台的输出结果为：
原始坐标为： (0,1), (0,2), (0,3), (1,2) 调用moveRight方法后的坐标： (0,2), (0,3), (0,4), (1,3)
从输出结果上，可以看出T型方块中的每个格子的列都在原有的基础上增加了1。界面对比效果如图-6所示。
右移前 右移后
图- 6
另外，测试下落方法，测试左移方法与测试右移方法类似，请自行测试。
步骤九：定义J类并实现
J类的实现和T类是类似的，主要注意，在J类的构造方法中，按照J型进行初始化cells属性。从图-7中，按顺时针方向查看J型方块，可以看出，第一个格子的行列坐标是（17，3），第二个格子的行列坐标是（17，4），第三个格子的行列坐标是（17，5），第四个格子的行列坐标是（18，5）。
假设把第一个格子的行列坐标用(row，col)来表示，那么,第二个格子的行列坐标为(row,col+1), 第三个格子的行列坐标为(row,col+2), 第四个格子的坐标为(row+1,col+2),这样，J型方块就可以用传入的参数对cells属性进行初始了。
图- 7
另外，打印的方法print、方块下落的方法drop、方块左移的方法moveLeft和方块右移的方法moveRight与T类的实现方式相同。J类代码实现如下所示：
public class J {
Cell[] cells;// 属性,用来存储一个方块的四个格子的坐标
/**
* 构造方法，为属性cells进行初始化
*/
public J() {
this(0, 0);
}
/**
* 构造方法，为属性cells进行初始化
*
* @param row
* 顺时针方向 ，第一个坐标的行
* @param col
* 顺时针方向 ，第一个坐标的列
*/
public J(int row, int col) {
cells = new Cell[4];
// 按顺时针方向初始化Cell
cells[0] = new Cell(row, col);
cells[1] = new Cell(row, col + 1);
cells[2] = new Cell(row, col + 2);
cells[3] = new Cell(row + 1, col + 2);
}
/**
* 按顺时针方向，打印方块中四个格子所在的坐标
*/
public void print() {
String str = "";
for (int i = 0; i < cells.length - 1; i++) {
str += "(" + cells[i].getCellInfo() + "), ";
}
str += "(" + cells[cells.length - 1].getCellInfo() + ")";
System.out.println(str);
}
/**
* 使方块下落一个格子
*/
public void drop() {
for (int i = 0; i < cells.length; i++) {
cells[i].row++;
}
}
/**
* 使方块左移一个格子
*/
public void moveLeft() {
for (int i = 0; i < cells.length; i++) {
cells[i].col--;
}
}
/**
* 使方块右移一个格子
*/
public void moveRight() {
for (int i = 0; i < cells.length; i++) {
cells[i].col++;
}
}
}
步骤十：测试J类中的方法
测试J类中方法的过程，与测试T类中方法的过程类似，这里不再赘述。TestJ类代码如下所示：
public class TestJ {
public static void main(String[] args) {
J j=new J(17,3);
//测试print方法
System.out.println("原始坐标为：");
j.print();
//测试drop方法
// j.drop();
// System.out.println("调用drop方法后的坐标：");
// j.print();
//测试moveLeft方法
// j.moveLeft();
// System.out.println("调用moveLeft方法后的坐标：");
// j.print();
//测试moveRight方法
j.moveRight();
System.out.println("调用moveRight方法后的坐标：");
j.print();
}
4.4 完整代码
本案例中，T类的完整代码如下所示：
public class T {
Cell[] cells;// 属性,用来存储一个方块的四个格子的坐标
/**
* 构造方法，为属性cells进行初始化
*/
public T() {
this(0, 0);
}
/**
* 构造方法，为属性cells进行初始化
*
* @param row
* 顺时针方向 ，第一个坐标的行
* @param col
* 顺时针方向 ，第一个坐标的列
*/
public T(int row, int col) {
cells = new Cell[4];
// 按顺时针方向初始化Cell
cells[0] = new Cell(row, col);
cells[1] = new Cell(row, col + 1);
cells[2] = new Cell(row, col + 2);
cells[3] = new Cell(row + 1, col + 1);
}
/**
* 按顺时针方向，打印方块中四个格子所在的坐标
*/
public void print() {
String str = "";
for (int i = 0; i < cells.length - 1; i++) {
str += "(" + cells[i].getCellInfo() + "), ";
}
str += "(" + cells[cells.length - 1].getCellInfo() + ")";
System.out.println(str);
}
/**
* 使方块下落一个格子
*/
public void drop() {
for (int i = 0; i < cells.length; i++) {
cells[i].row++;
}
}
/**
* 使方块左移一个格子
*/
public void moveLeft() {
for (int i = 0; i < cells.length; i++) {
cells[i].col--;
}
}
/**
* 使方块右移一个格子
*/
public void moveRight() {
for (int i = 0; i < cells.length; i++) {
cells[i].col++;
}
}
}
TestT类完整代码如下所示：
public class TestT {
public static void main(String[] args) {
T t=new T(0,1);
//测试print方法
System.out.println("原始坐标为：");
t.print();
//测试drop方法
// t.drop();
// System.out.println("调用drop方法后的坐标：");
// t.print();
//测试moveLeft方法
// t.moveLeft();
// System.out.println("调用moveLeft方法后的坐标：");
// t.print();
//测试moveRight方法
t.moveRight();
System.out.println("调用moveRight方法后的坐标：");
t.print();
}
}
J类的完整代码如下所示：
public class J {
Cell[] cells;// 属性,用来存储一个方块的四个格子的坐标
/**
* 构造方法，为属性cells进行初始化
*/
public J() {
this(0, 0);
}
/**
* 构造方法，为属性cells进行初始化
*
* @param row
* 顺时针方向 ，第一个坐标的行
* @param col
* 顺时针方向 ，第一个坐标的列
*/
public J(int row, int col) {
cells = new Cell[4];
// 按顺时针方向初始化Cell
cells[0] = new Cell(row, col);
cells[1] = new Cell(row, col + 1);
cells[2] = new Cell(row, col + 2);
cells[3] = new Cell(row + 1, col + 2);
}
/**
* 按顺时针方向，打印方块中四个格子所在的坐标
*/
public void print() {
String str = "";
for (int i = 0; i < cells.length - 1; i++) {
str += "(" + cells[i].getCellInfo() + "), ";
}
str += "(" + cells[cells.length - 1].getCellInfo() + ")";
System.out.println(str);
}
/**
* 使方块下落一个格子
*/
public void drop() {
for (int i = 0; i < cells.length; i++) {
cells[i].row++;
}
}
/**
* 使方块左移一个格子
*/
public void moveLeft() {
for (int i = 0; i < cells.length; i++) {
cells[i].col--;
}
}
/**
* 使方块右移一个格子
*/
public void moveRight() {
for (int i = 0; i < cells.length; i++) {
cells[i].col++;
}
}
}
TestJ类的完整代码如下所示：
public class TestJ {
public static void main(String[] args) {
J j=new J(17,3);
//测试print方法
System.out.println("原始坐标为：");
j.print();
//测试drop方法
// j.drop();
// System.out.println("调用drop方法后的坐标：");
// j.print();
//测试moveLeft方法
// j.moveLeft();
// System.out.println("调用moveLeft方法后的坐标：");
// j.print();
//测试moveRight方法
j.moveRight();
System.out.println("调用moveRight方法后的坐标：");
j.print();
}