Java入门第53课——俄罗斯方块项目中的T类和J类

我会带着你远行 2022-01-28 15:11 253阅读 0赞

## 问题 ##

在Tetris游戏中，游戏场地由10列×20行个正方形格子构成，如图所示，每个方块由四个格子组成，绘制在场地中，如图所示中的红色方块。

![image.png][]

4个小型正方形格子组成的规则图形(Tetromino),共有7种，分别以S、Z、L、J、I、O、T这7个字母的形状来命名，各个图形形状如下图所示。

![image.png][image.png 1]

之前案例中定义的Cell类，表示游戏场地中的一个正方形格子，存储其在场地中的位置。本案例中会使用到Cell类，拷贝之前案例中的该类使用即可。本案例要求定义表示T型方块的类T和J型方块的类J。T型方块和J型方块的形状如上图所示中的黄色方块和紫色方块。

## 方案 ##

要实现本案例要求的功能，解决方法如下：

1.定义名为T的类，由于每个方块有四个格子，因此，在T类中添加属性cells，cells属性的类型为Cell数组类型，即，Cell\[\]。这样，cells数组中就可以存储四个格子来表示一个方块。

2. 为T类添加构造方法。可以提供无参数构造方法，及按顺时针方向、方块中第一个格子的行和列作为参数的构造方法。

3.为了方便查看方块中四个格子的坐标，因此，定义print方法，实现按顺时针方向，打印方块中四个格子所在的坐标，并对print进行测试。

4.每个方块都可以下落，左移和右移，因此，在T类中，定义drop方法实现方块下落；定义moveLeft方法实现方块左移；定义moveRight方法实现方块右移，并对这三个方法进行测试。

5.实现J类。J类的实现和T类是类似的，主要注意，在构造方法中，按照J型进行初始化cells属性，并进行测试。

## 步骤 ##

实现此案例需要按照如下步骤进行。

## 步骤一：定义T类 ##

首先定义一个名为T的类，代码如下所示：

public class T{
    }

## 步骤二：定义属性 ##

由于每个方块有四个格子，因此，在类T中定义一个名为cells的属性，cells属性的类型为Cell数组类型，即，Cell\[\]。代码如下所示：

public class T{
            Cell[] cells;
        }

## 步骤三：定义构造方法 ##

首先，在T类中添加第一个格子的行和列作为参数的构造方法，并在构造方法按顺时针方向初始化T型方块。

![image.png][image.png 2]

由上图中，按顺时针方向查看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;
            
            /**
             *构造方法，为属性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);
             }
        }

在T类中添加无参数构造方法，在该构造方法中，使用this关键字调用参数为T(int row,int col)的构造方法，并设置方块的顺时针方向的第一个格子的行和列为(0,0),代码如下所示：

## 步骤四：定义打印方法 ##

为了方便查看方块中的四个格子的坐标，因此，定义print方法。在print方法真能干，按顺时针方向，打印方块中的四个格子所在的坐标。实现此功能，循环遍历cells数组即可。代码如下所示：

## 步骤五：定义方块的下落方法 ##

定义方块的下落方法，即，在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++;
                   }
               }
        }

## 步骤六：定义方块的左移方法 ##

定义方块的左移的方法，即，在T类中，添加方块左移一个格子的方法。要实现方块左移一个格子，只需要循环cells属性，将方块中的每一个格子的列减1即可。代码如下所示：

## 步骤七：定义方块的右移方法 ##

定义方块的右移的方法，即，在T类中，添加方块右移一个格子的方法。要实现方块右移一个格子，只需要循环cells属性，将方块中的每一个格子的列加1即可。代码如下所示：

## 步骤八：测试方块的右移方法 ##

新建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();
                
                //测试moveRight方法
                t.moveRight();
                System.out.println("调用moveRight方法后的坐标:");
                t.print();
            }
        }

控制台的输出结果为：

原始坐标为:
        (0,1),(0,2),(0,3),(1,2)
        调用moveRight方法后的坐标:
        (0,2),(0,3),(0,4),(1,3)

从输出结果上，可以看出T型方块中的每个格子的列都在原有的基础上增加了1.界面对比效果如图所示。

![image.png][image.png 3]

另外，测试下落方法，测试左移方法与测试右移方法类似，请自行测试。

## 步骤九：定义J类并实现 ##

J类的实现和T类是类似的，主要注意，在J类的构造方法中，按照J型进行初始化cells属性。从下图中，按顺时针方向查看J型方块，可以看出，第一个格子的行列坐标是(17,3),第二个格子的行列坐标是(17,4)，第三个格子的行列坐标是(17,5)，第四个格子的行列坐标是(18,5)。

假设把第一个格子的行列坐标用(row,col)来表示，那么，第二个格子的行列坐标为(row,col+1)，第三个格子的行列坐标为(row,col+2)，第四个格子的坐标为(row+1,col+2)，这样，J型方块就可以用传入的参数对cells属性进行初始化了。

![image.png][image.png 4]

另外，打印的方法print、方块下落的方法drop、方块左移的方法moveLeft和方块右移的方法moveRight与T类的实现方式相同。J类代码实现如下所示：

public class J{
            Cell[] cells//属性，用来存储一个方块的四个格子的坐标
            
            /**
             *构造方法，为属性cells进行初始化
             */
             public J(){
                 this(0,0);
             }
             
             /**
              *构造方法，为属性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();
            }
        }

# 博主点评： #

本节内容介绍了T和J型方块的定义，可以帮助初学者理解面向对象的概念。万物皆对象，任何事物都可以用面向对象的思想定义为一个类，读者可以自己尝试定义一个事物，比如人、书本等。

初学者容易忘记初始化cells数组，即cells=new Cell\[4\]这段代码。而且当运行的效果不符时，初学者往往会说：“我明明和老师写的一模一样啊”。其实，就是因为粗心，导致代码确实和老师写的不一样。因此，当运行结果不正确时，不要心烦意乱，而要静下心来找错，一定要细心。

扫码关注我吧：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2hvdWp1bmthbmczNjM_size_16_color_FFFFFF_t_70][]

[image.png]: /images/20220128/8c824830aba74909b4328afe571689ae.png
[image.png 1]: /images/20220128/d02fc5a6ddee4717969ef289c7d23050.png
[image.png 2]: /images/20220128/6e110ddd665f4dd4bfc266f3be04395a.png
[image.png 3]: /images/20220128/cb54048b9580429c98ece3e532b33e2c.png
[image.png 4]: /images/20220128/c2fbe6ac53414ddb90a06847309fb098.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2hvdWp1bmthbmczNjM_size_16_color_FFFFFF_t_70]: /images/20220128/0a52086bbd104d9395f7543cc401d5c3.png