第六个java程序（简单生命游戏）

前言：

     终于到了第六个java程序，这一个程序就是演示生命游戏，所谓的生命游戏，简洁地解释就是细胞的生命动态展示。

来看看这个规律：

                    1.一个细胞可以有8个邻居；
                    2.一个细胞若只有一个邻居，在下一代会孤独的死去；
                    3.若有2或3个邻居，在下一代依然活着；
                    4.若有4个或以上邻居，在下一代会因拥挤而死；
                    5.死去的细胞若有3个邻居，在下一代会复活；
                    6.所有的死去或复活都在下一代变化时同时发生。

    看了这个基本就理解了。所以我可以说一下自己的思路。首先我需要随机的初始化一个给定的二维数组，来代表细胞。然后按照上面的规律来判断当前细胞的下一次的生命变化，之后打印下一代。是的，这个程序是很简单的，我看了有很多的博主用图形界面来写，这个其实也很好理解。就是在框架里面添加组件，填充方块或者圆形，可以参考我的第三个java程序，里面的图形界面也可以参考。这里我决定用简单的空白点来写，这个也是借用了其它博主的思路：（https://blog.csdn.net/weixin_44013961/article/details/89577089），因为1,0显示也太过于单调了。图形显示的话其实对于这个简单的演示来说就比较麻烦了。而且有更好的结构其它博主写得超级好，大家可以去康康哦（图形界面的）。

来来，康康代码。

老规矩，创建我们的项目，创建包，这次我们在一个包里面创建两个类（主要是方便调试，嘻嘻）。

第一个类

package shiyan;

import java.util.Random;
import java.util.Scanner;

    /*
    1.生命小游戏的邻居为上下左右和斜对角一共八个位置;
    2.默认选择10*10的格子。
    3.将默认的格子初始化，并打印输出
    4.使用Methods中的方法生成下一轮的状态，并打印
     */

public class sixlife {
    public static void main(String[] args) {

        //先设置一个二维数组存储所有的格子
        String[][] lifeMap = new String[10][10];

        sixmachine me = new sixmachine();

        //对所有格子进行初始化输入，死为0，活为1
        //随机生成各个位置的邻居情况
        for (int i = 0; i <10; i++) {
            for (int j = 0; j < 10; j++) {

                int num = new Random().nextInt(2);
                if (num == 1)
                    lifeMap[i][j] = "●";
                else if (num == 0)
                    lifeMap[i][j] = "o";
            }
        }

        //打印格子初始状态
        System.out.println("初始状态为：");
        me.printLifeMap1(lifeMap);
        System.out.println("===========");

        int n = 0;
        int num = 0;//记录变化的次数
        while (n == 0) {

            //用point数组，记录对应位置下一轮的状态，1下一代死，2下一代继续活，3下一代复活
            int[] point = me.check(lifeMap, new int[100]);

            //获得下一次变化后的图形
            lifeMap = me.getNext(lifeMap, point).clone();

            System.out.println("第" + (++num) + "次变化：");

            //打印出来
            me.printLifeMap(lifeMap);
            System.out.println("===========");

            System.out.println("输入0继续进行下一步，输入其他数字退出。");
            n = new Scanner(System.in).nextInt();
        }
    }
}

第二个类：

package shiyan;

public class sixmachine {

    public sixmachine() {}

    //该方法检测所有位置，并返回对应位置的point数组
    //用point数组，记录对应位置下一轮的状态，1下一代死，2下一代继续活，3下一代复活
    public int[] check(String[][] lifeMap, int[] point) {

        int n = 0;
        //统计周围邻居的情况
        for (int i = 0; i < 10; i++) {
            for (int j = 0; j < 10; j++) {

                /*
                规则如下，进行判断
                    1.一个细胞可以有8个邻居；
                    2.一个细胞若只有一个邻居，在下一代会孤独的死去；
                    3.若有2或3个邻居，在下一代依然活着；
                    4.若有4个或以上邻居，在下一代会因拥挤而死；
                    5.死去的细胞若有3个邻居，在下一代会复活；
                    6.所有的死去或复活都在下一代变化时同时发生。


                */

                //用life变量记录周围活着的邻居个数
                int life = 0;

                //1.判断正下方的位置
                if (i + 1 < 4 && lifeMap[i + 1][j].equals("●")) {
                    life++;
                }

                //2.判断右下位置
                if (i + 1 < 4 && j + 1 < 4 && lifeMap[i + 1][j + 1].equals("●")) {
                    life++;
                }

                //3.判断左下位置
                if (i + 1 < 4 && j - 1 >= 0 && lifeMap[i + 1][j - 1].equals("●")) {
                    life++;
                }

                //4.判断右侧位置
                if (j + 1 < 4 && lifeMap[i][j + 1].equals("●")) {
                    life++;
                }

                //5.判断左侧位置
                if (j - 1 >= 0 && lifeMap[i][j - 1].equals("●")) {
                    life++;
                }

                //6.判断正上方位置
                if (i - 1 >= 0 && lifeMap[i - 1][j].equals("●")) {
                    life++;
                }

                //7.判断右上位置
                if (i - 1 >= 0 && j + 1 < 4 && lifeMap[i - 1][j + 1].equals("●")) {
                    life++;
                }

                //8.判断左上位置
                if (i - 1 >= 0 && j - 1 >= 0 && lifeMap[i - 1][j - 1].equals("●")) {
                    life++;
                }

                //用一个数组，记录对应位置下一轮的状态，1下一代死，2下一代继续活，3下一代复活
                if (lifeMap[i][j].equals("●")) {
                    if (life == 1)
                        point[n] = 1;
                    else if (life == 2 || life == 3)
                        point[n] = 2;
                    else if (life >= 4)
                        point[n] = 1;
                } else {
                    if (life == 3)
                        point[n] = 3;
                }
                n++;
            }
        }
        return point;
    }

    public String[][] getNext(String[][] lifeMap, int[] point) {

        int n = 0;
        for (int i = 0; i < 10; i++) {
            for (int j = 0; j < 10; j++) {

                //变更状态
                if (point[n] == 1)
                 lifeMap[i][j] = "o";                    
                if (point[n] == 3)
                    {lifeMap[i][j] = "●";
                n++;
            }
        }
        }
        return lifeMap;
    }
    public void printLifeMap1(String[][] lifeMap){
        for (int i = 0; i < 10; i++) {
            for (int j = 0; j < 10; j++) {
                if (j == 9)
                    System.out.println(lifeMap[i][j] + " ");
                else
                    System.out.print(lifeMap[i][j] + " ");
            }
        }
    }
    public int lifeLabour(String[][] lifeMap,int i,int j) {
    	String [][] lifeMa = new String[10][10];
    	for(int p=0;p<10;p++)
    		for(int q=0;q<10;q++) {
    			lifeMa[p][q]=lifeMap[p][q];
    		}
    	int life = 0;
        //1.判断正下方的位置
        if (i + 1 < 4 && lifeMa[i + 1][j].equals("●")) {
            life++;
        }

        //2.判断右下位置
        if (i + 1 < 4 && j + 1 < 4 && lifeMa[i + 1][j + 1].equals("●")) {
            life++;
        }

        //3.判断左下位置
        if (i + 1 < 4 && j - 1 >= 0 && lifeMa[i + 1][j - 1].equals("●")) {
            life++;
        }

        //4.判断右侧位置
        if (j + 1 < 4 && lifeMa[i][j + 1].equals("●")) {
            life++;
        }

        //5.判断左侧位置
        if (j - 1 >= 0 && lifeMa[i][j - 1].equals("●")) {
            life++;
        }

        //6.判断正上方位置
        if (i - 1 >= 0 && lifeMa[i - 1][j].equals("●")) {
            life++;
        }
      
        //7.判断右上位置
        if (i - 1 >= 0 && j + 1 < 4 && lifeMa[i - 1][j + 1].equals("●")) {
            life++;
        }

        //8.判断左上位置
        if (i - 1 >= 0 && j - 1 >= 0 && lifeMa[i - 1][j - 1].equals("●")) {
            life++;
        }
    
    	 
    	 return life;
    }
    public void printLifeMap(String[][] lifeMap){
        for (int i = 0; i < 10; i++) {
            for (int j = 0; j < 10; j++) {
                if (j == 9)
                    System.out.println(lifeMap[i][j] + " ");
                else
                    System.out.print(lifeMap[i][j] + " ");
            }
        }
        System.out.println();
        for (int i = 0; i < 10; i++) {
            for (int j = 0; j < 10; j++) {
                //变更状态
                if (lifeMap[i][j]=="o")
                {System.out.print("[" +i+ "][" + j + "]:"+"dead");
                System.out.print(":" + lifeLabour(lifeMap,i,j) + "-->");
                System.out.println();
                }
    			else if(lifeMap[i][j] == "●")
                    {System.out.print("[" +i+ "][" + j + "]:"+"live"); 
                    System.out.print(":" + lifeLabour(lifeMap,i,j) + "-->");
                    System.out.println();}
         
            }
        }
        
    }
    
}

我们来看看演示的样子：

这个打印了演示的过程，打印每一个细胞当前的存活状态，周围细胞的存活状态。

后记：

  代码可以优化可以评论哦，终于做到了第六个，冲冲冲！！！