实验五、单元测试

1 package lifegame;
  2 
  3 public class Methods {
  4      public Methods() {
  5         }
  6 
  7         //该方法检测所有位置，并返回对应位置的point数组
  8         //用point数组，记录对应位置下一轮的状态，1下一代死，2下一代继续活，3下一代复活
  9         public int[] check(String[][] lifeMap, int[] point) {
 10 
 11             int n = 0;
 12             //统计周围邻居的情况
 13             for (int i = 0; i < 4; i++) {
 14                 for (int j = 0; j < 4; j++) {
 15 
 16                     /*
 17                     规则如下，进行判断
 18                                       （ 1）一个人可以有8个邻居；
 19                                       （ 2）一个人若只有一个邻居，在下一代会孤独的死去；
 20                             （3）若有2或3个邻居，在下一代依然活着；
 21                             （4）若有4个或以上邻居，在下一代会因拥挤而死；
 22                             （5）死去的人若有3个邻居，在下一代会复活；
 23                             （6）所有的死去或复活都在下一代变化时同时发生。
 24                     */
 25 
 26                     //用life变量记录周围活着的邻居个数
 27                     int life = 0;
 28 
 29                     //1.判断正下方的位置
 30                     if (i + 1 < 4 && lifeMap[i + 1][j].equals("●")) {
 31                         life++;
 32                     }
 33 
 34                     //2.判断右下位置
 35                     if (i + 1 < 4 && j + 1 < 4 && lifeMap[i + 1][j + 1].equals("●")) {
 36                         life++;
 37                     }
 38 
 39                     //3.判断左下位置
 40                     if (i + 1 < 4 && j - 1 >= 0 && lifeMap[i + 1][j - 1].equals("●")) {
 41                         life++;
 42                     }
 43 
 44                     //4.判断右侧位置
 45                     if (j + 1 < 4 && lifeMap[i][j + 1].equals("●")) {
 46                         life++;
 47                     }
 48 
 49                     //5.判断左侧位置
 50                     if (j - 1 >= 0 && lifeMap[i][j - 1].equals("●")) {
 51                         life++;
 52                     }
 53 
 54                     //6.判断正上方位置
 55                     if (i - 1 >= 0 && lifeMap[i - 1][j].equals("●")) {
 56                         life++;
 57                     }
 58 
 59                     //7.判断右上位置
 60                     if (i - 1 >= 0 && j + 1 < 4 && lifeMap[i - 1][j + 1].equals("●")) {
 61                         life++;
 62                     }
 63 
 64                     //8.判断左上位置
 65                     if (i - 1 >= 0 && j - 1 >= 0 && lifeMap[i - 1][j - 1].equals("●")) {
 66                         life++;
 67                     }
 68 
 69                     //用一个数组，记录对应位置下一轮的状态，1下一代死，2下一代继续活，3下一代复活
 70                     if (lifeMap[i][j].equals("●")) {
 71                         if (life == 1)
 72                             point[n] = 1;
 73                         else if (life == 2 || life == 3)
 74                             point[n] = 2;
 75                         else if (life >= 4)
 76                             point[n] = 1;
 77                     } else {
 78                         if (life == 3)
 79                             point[n] = 3;
 80                     }
 81                     n++;
 82                 }
 83             }
 84             return point;
 85         }
 86 
 87         public String[][] getNext(String[][] lifeMap, int[] point) {
 88 
 89             int n = 0;
 90             for (int i = 0; i < 4; i++) {
 91                 for (int j = 0; j < 4; j++) {
 92 
 93                     //变更状态
 94                     if (point[n] == 1)
 95                         lifeMap[i][j] = "○";
 96                     if (point[n] == 3)
 97                         lifeMap[i][j] = "●";
 98 
 99                     n++;
100                 }
101             }
102             return lifeMap;
103         }
104 
105         public void printLifeMap(String[][] lifeMap){
106             for (int i = 0; i < 4; i++) {
107                 for (int j = 0; j < 4; j++) {
108                     if (j == 3)
109                         System.out.println(lifeMap[i][j] + " ");
110                     else
111                         System.out.print(lifeMap[i][j] + " ");
112                 }
113             }
114         }
115 }

1 package lifegame;
 2 
 3 import java.util.Random;
 4 import java.util.Scanner;
 5 
 6     /*
 7         （1）生命小游戏的邻居为上下左右和斜对角一共八个位置
 8         （2）默认选择4*4的格子
 9         （3）将默认的格子初始化，并打印输出
10         （4）使用Methods中的方法生成下一轮的状态，并打印
11      */
12 
13 public class LifeGame {
14     public static void main(String[] args) {
15 
16             //设置一个二维数组存储所有的格子
17             String[][] lifeMap = new String[4][4];
18 
19             Methods me = new Methods();
20 
21             //将所有格子进行初始化输入，死为0，活为1
22             //随机生成各个位置的邻居情况
23             for (int i = 0; i < 4; i++) {
24                 for (int j = 0; j < 4; j++) {
25 
26                     int num = new Random().nextInt(2);
27                     if (num == 1)
28                         lifeMap[i][j] = "●";
29                     else if (num == 0)
30                         lifeMap[i][j] = "○";
31                 }
32             }
33 
34             //打印格子初始状态
35             System.out.println("初始状态为：");
36             me.printLifeMap(lifeMap);
37             System.out.println("===========");
38             
39             Scanner scan = new Scanner(System.in);
40             int n = 0;
41             int num = 0;//记录变化的次数
42             while (n == 0) {
43 
44                 //用point数组，记录对应位置下一轮的状态，1下一代死，2下一代继续活，3下一代复活
45                 int[] point = me.check(lifeMap, new int[16]);
46 
47                 //将获得下一次变化后的图形
48                 lifeMap = me.getNext(lifeMap, point).clone();
49 
50                 System.out.println("第" + (++num) + "次变化：");
51 
52                 //打印出来
53                 me.printLifeMap(lifeMap);
54                 System.out.println("===========");
55 
56                 System.out.println("输入0继续进行下一步，输入其他数字退出。");
57                 if(scan.hasNextInt()) {
58                     n = scan.nextInt();
59                 }
60                 else n = 1;
61             }
62             scan.close();
63         }
64 }