细胞自动机与数据与表现分离

　　细胞自动机的Java实现
一丶
先说说这个题目吧，还是第一次接触这种类型的题目：生命游戏中，对于任意细胞，规则如下：
每个细胞有两种状态-存活或死亡，每个细胞与以自身为中心的周围八格细胞产生互动。
当前细胞为存活状态时，当周围低于2个（不包含2个）存活细胞时， 该细胞变成死亡状态。（模拟生命数量稀少）
当前细胞为存活状态时，当周围有2个或3个存活细胞时， 该细胞保持原样。
当前细胞为存活状态时，当周围有3个以上的存活细胞时，该细胞变成死亡状态。（模拟生命数量过多）
当前细胞为死亡状态时，当周围有3个存活细胞时，该细胞变成存活状态。 （模拟繁殖）
可以把最初的细胞结构定义为种子，当所有在种子中的细胞同时被以上规则处理后, 可以得到第一代细胞图。按规则继续处理当前的细胞图，可以得到下一代的细胞图，周而复始。
1.看到这个题目的第一反应是将整个生命环境看作一个矩阵，其中的每一个细胞以二维坐标的形式存在于环境中，那么这个细胞类就有三个属性在生命游戏中的：x坐标，y坐标，生命状态。但是，这样做了以后发现两个问题：
1）环境边界处的细胞生命状态判断实现很难。
2）细胞之间的生命状态无法实现关联关系。
2.之后是将单个细胞单独做一个（BasicUnit类），还是以3*3九宫格的方式判段我们抽象出来的单元细胞的生命状态，再将其放入生命游戏沙盘（LifeGame类）中演变，当然，还是写一个细胞信息类（Cell类）将从BasicUnit类中判断得来的细胞生命状态和在LifeGame类中的坐标两个信息存储起来。
3.到此，整个生命游戏的实现逻辑就构建好了，接下来就是编码实现的事情了。
4.编码过程中遇到很多坑，这里就不多提了，碰到的坑都是为了以后少进坑做贡献。
5.下面讲这三个类代码贴出来（不能直接跑，用了单元测试，测试每个类的逻辑是否实现，要跑的话需要自己写一个run类）


BasicUnit类：

1. package org.coach.tdd.template;
3. /**
4. * Created by lzy on 17-6-3.
5. */
7. /**
8. * BasicUnit类判断单元细胞的生命状态。
9. */
10. public class BasicUnit {
11.     private static final int DEATH = 0;
12.     private static final int LIVE = 1;
13.     private int[][] testUnit = new int[3][3]; //将一个细胞及其周围相邻细胞看作一个基本单元
14.     private int status = DEATH;
16.     public void setTestUnit(int[][] testUnit) {
17.         this.testUnit = testUnit;
18.     }
20.     /**
21.      * .
22.      * 获得单元细胞生命状态
23.      *
24.      * @param basicUnit 该细胞周围细胞生命状态
25.      * @return 该细胞生命状态
26.      */
27.     public int getUnitCelltatus(int[][] basicUnit) {
28.         int numberofcell = 0;
29.         for (int i = 0; i < 3; i++) {
30.             for (int j = 0; j < 3; j++) {
31.                 if (1 == basicUnit[i][j]) {
32.                     if (1 == i && 1 == j) {
33.                     } else {
34.                         numberofcell += 1;
35.                     }
36.                 }
37.             }
38.         }
39.         if (3 == numberofcell) {
40.             return 1;
41.         } else if (2 == numberofcell) {
42.             return basicUnit[1][1];
43.         }
44.         return 0;
45.     }
46. }

复制代码

 Cell类：

1. package org.coach.tdd.template;
3. /**
4. * Created by lzy on 17-6-3.
5. */
7. /**
8. * Cell类存储细胞的坐标，生命状态，周围细胞状态。
9. */
10. public class Cell {
11.     private int location_x = 0;
12.     private int location_y = 0;
13.     private int cellStatus = 0;
14.     private int[][] aroundCells = new int[3][3];
16.     /**
17.      * 构造方法的描述
18.      *
19.      * @param location_x 细胞的x坐标
20.      * @param location_y 细胞的y坐标
21.      * @param cellStatus 细胞的状态
22.      */
23.     public Cell(int location_x, int location_y, int cellStatus) {
24.         this.location_x = location_x;
25.         this.location_y = location_y;
26.         this.cellStatus = cellStatus;
27.     }
29.     public int getLocation_x() {
30.         return location_x;
31.     }
33.     public int getLocation_y() {
34.         return location_y;
35.     }
37.     public int getCellStatus() {
38.         return cellStatus;
39.     }
41.     public void setCellStatus(int cellStatus) {
42.         this.cellStatus = cellStatus;
43.     }
45.     /**
46.      * 获取更新后的细胞状态
47.      *
48.      * @return
49.      */
50.     public int getAfterTurnCellStatus() {
51.         BasicUnit basicUnit = new BasicUnit();
52.         this.setCellStatus(basicUnit.getUnitCelltatus(aroundCells));
53.         return this.getCellStatus();
54.     }
55. }

复制代码

LifeGame类：

1. package org.coach.tdd.template;
3. /**
4. * Created by lzy on 17-6-3.
5. */
7. /**
8. * LifeGame类生命游戏具体操作类
9. */
12. public class LifeGame {
13.     public static final int LEFTUP = 1;
14.     public static final int RIGHTUP = 2;
15.     public static final int LEFTDOWN = 3;
16.     public static final int RIGHTDOWN = 4;
17.     private int framesize = 0; //框架大小，表示为正方体框架的边长
18.     private int[][] frame;
19.     private int[][] nextframe;
21.     public LifeGame(int framesize) {
22.         this.framesize = framesize;
23.     }
25.     public int[][] getNextframe() {
26.         return nextframe;
27.     }
29.     public void setFrame(int[][] frame) {
30.         this.frame = frame;
31.     }
33.     public void init() {
34.         frame = new int[framesize][framesize];
35.         nextframe = new int[framesize][framesize];
36.     }
38.     public void putCell(Cell cell) {
39.         frame[cell.getLocation_x()][cell.getLocation_y()] = cell.getCellStatus();
41.     }
44.     public int locationIsCorner(int x, int y) {
45.         if (0 == x && 0 == y) {
46.             return LEFTUP;
47.         } else if (0 == x && framesize - 1 == y) {
48.             return RIGHTUP;
49.         } else if (framesize - 1 == x && 0 == y) {
50.             return LEFTDOWN;
51.         } else if (framesize - 1 == x && framesize - 1 == y) {
52.             return RIGHTDOWN;
53.         }
54.         return 0;
55.     }
57.     public int locationIsLine(int x, int y) {
58.         if (0 == x && 0 != y && framesize - 1 != y) {
59.             return 11;
60.         } else if (framesize - 1 == x && 0 != y && framesize - 1 != y) {
61.             return 12;
62.         } else if (0 == y && 0 != x && framesize - 1 != x) {
63.             return 13;
64.         } else if (framesize - 1 == y && 0 != x && framesize - 1 != x) {
65.             return 14;
66.         }
67.         return 0;
68.     }
70.     /**
71.      * 获取指定坐标细胞周围细胞状态
72.      *
73.      * @param x cell_x坐标
74.      * @param y cell_y坐标
75.      * @return 指定坐标细胞周围细胞状态
76.      */
77.     public int[][] getAroundStatus(int x, int y) {
78.         //corner
79.         int[][] aroundUnit = new int[3][3];
80.         int isCorner = locationIsCorner(x, y);
81.         int isLine = locationIsLine(x, y);
82.         if (isCorner != 0) {
83.             switch (isCorner) {
84.                 case 1: {
85.                     aroundUnit = new int[][]{{frame[x][y + 1], frame[x + 1][y], frame[x + 1][y + 1]}, {0, frame[x][y], 0}, {0, 0, 0}};
86.                     break;
87.                 }
88.                 case 2: {
89.                     aroundUnit = new int[][]{{frame[x][y - 1], frame[x + 1][y - 1], frame[x + 1][y]}, {0, frame[x][y], 0}, {0, 0, 0}};
90.                     break;
91.                 }
92.                 case 3: {
93.                     aroundUnit = new int[][]{{frame[x - 1][y], frame[x - 1][y + 1], frame[x][y + 1]}, {0, frame[x][y], 0}, {0, 0, 0}};
94.                     break;
95.                 }
96.                 case 4: {
97.                     aroundUnit = new int[][]{{frame[x - 1][y], frame[x - 1][y - 1], frame[x][y - 1]}, {0, frame[x][y], 0}, {0, 0, 0}};
98.                     break;
99.                 }
100.                 default:
101.                     break;
102.             }
103.         }
104.         //line
105.         else if (isLine != 0) {
106.             switch (isCorner) {
107.                 case 11: {
108.                     aroundUnit = new int[][]{{frame[x][y - 1], frame[x][y + 1], frame[x + 1][y - 1]}, {frame[x + 1][y], frame[x][y], frame[x + 1][y + 1]}, {0, 0, 0}};
109.                     break;
110.                 }
111.                 case 12: {
112.                     aroundUnit = new int[][]{{frame[x - 1][y - 1], frame[x - 1][y], frame[x - 1][y + 1]}, {frame[x][y - 1], frame[x][y], frame[x][y + 1]}, {0, 0, 0}};
113.                     break;
114.                 }
115.                 case 13: {
116.                     aroundUnit = new int[][]{{frame[x - 1][y], frame[x - 1][y + 1], frame[x][y + 1]}, {frame[x + 1][y], frame[x][y], frame[x + 1][y + 1]}, {0, 0, 0}};
117.                     break;
118.                 }
119.                 case 14: {
120.                     aroundUnit = new int[][]{{frame[x - 1][y - 1], frame[x - 1][y], frame[x][y - 1]}, {frame[x + 1][y - 1], frame[x][y], frame[x + 1][y]}, {0, 0, 0}};
121.                     break;
122.                 }
123.                 default:
124.                     break;
125.             }
126.         } else {
127.             aroundUnit = new int[][]{{frame[x - 1][y - 1], frame[x - 1][y], frame[x - 1][y + 1]}, {frame[x][y - 1], frame[x][y], frame[x][y + 1]}, {frame[x + 1][y - 1], frame[x + 1][y], frame[x + 1][y + 1]}};
129.         }
130.         return aroundUnit;
131.     }
133.     /**
134.      * 更新环境中所有细胞生命状态
135.      *
136.      * @return 环境中是否还在活着的细胞
137.      */
138.     public boolean isfreshFrame() {
139. //      boolean flag =false;
140.         boolean hasLife = false;
141.         BasicUnit basicUnit = new BasicUnit();
142.         for (int i = 0; i < framesize; i++) {
143.             for (int j = 0; j < framesize; j++) {
144.                 int[][] aroundUnit = getAroundStatus(i, j);
145.                 int status = basicUnit.getUnitCelltatus(aroundUnit);
146.                 nextframe[i][j] = status;
147.             }
148.         }
149.         for (int i = 0; i < framesize; i++) {
150.             for (int j = 0; j < framesize; j++) {
151.                 System.out.print(frame[i][j]);
152.             }
153.             System.out.println("");
154.         }
155.         System.out.println("");
156.         for (int i = 0; i < framesize; i++) {
157.             for (int j = 0; j < framesize; j++) {
158.                 if (1 == nextframe[i][j]) {
159.                     hasLife = true;
160.                 }
161.                 System.out.print(nextframe[i][j]);
162.             }
163.             System.out.println("");
164.         }
165. //      flag=true;
166.         return hasLife;
167.     }
169.     /**
170.      * 运行整个生命游戏
171.      *
172.      * @param lifeGame 生命游戏的初始对象
173.      * @return 运行成功
174.      */
175.     public boolean run(LifeGame lifeGame) {
176.         while (lifeGame.isfreshFrame()) {
177.             lifeGame.setFrame(lifeGame.getNextframe());
178.             System.out.println("");
179.         }
180.         return true;
181.     }
182. }

复制代码

表现与数据分离
　　表现与数据数据分离
表现：顾名思义，就是表达出来的现象，在前端来看，就是html+css，就是平常所看到的的网页的架子；
数据：一般是从后端数据库或从哪爬过来的数据，然后在前台显示出来，即是网页中各个结构上的内容；
　　好处与坏处
好处：模块化 –> 容易测试 –> 降低bug频率；
坏处：程序结构复杂，比较耗时，上手有学习曲线；
　　应用场景：
项目具有明显的数据需求，比如要与很多Service交互，业务流程复杂，表单很多
　　非应用场景：
项目是典型的静态信息展示型页面，或是微型的内部app，或是产品idea验证时期的MVP。

1. <html xmlns="http://www.w3.org/1999/xhtml">
2. <head>
3.     <title></title>
4.    
5.    
6. </head>
7. <body>
8.     <select id="pili">
9.      <option value="叶小钗">叶小钗</option>
10.         <option value="一页书">一页书</option>
11.         <option value="素还真">素还真</option>
12.     </select>
13.    
14. </body>
15. </html>

复制代码

• 我们好像就在view中使用了选择器获取dom。
  
• 我们的数据似乎在model中，我们可以随意改变，但是并不会影响到我们dom。
  
• view和model是完全独立的，我们的controller恰好把他们串联起来了。
  

 

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！