模拟细菌（病毒）传播（java作业）

学习java到现在差不多11天了， 老师留了个作业，模拟病毒复制：
1.如果病毒周围有其他的病毒，并且有空气，则病毒繁殖到空气的位置上；
2.如果病毒周围全是病毒，则病毒会因为呼吸不到空气死亡；
3.如果病毒周围全是空气，则病毒会因为孤独至死。

下面具体实现：

新建一个Germ类：
/**
 * @(#)germ.java
 *
 *
 * @author LiuJie
 * @version 1.00 2007/4/13
 */

public class Germ {

    public Germ() {
    }
   
    int colNum = 3;//行数
    int rowNum = 3;//列数
   
    public int[][] germa = new int[colNum+2][rowNum+2];
    public int[][] germb = new int[colNum+2][rowNum+2];
   
    /**
     * 初始化矩阵germa，使边缘位置为3，中间位置为1或0
     * 1代表病毒，0代表空气
     *
     */   
    public void initialize(int[][] _germ){
     
        for (int i = 0; i<_germ.length; i++){
         
         for (int j = 0; j<_germ[i].length; j++){
          if(i == 0||i == _germ.length-1||j == 0||j == _germ[i].length-1){
           _germ[i][j] = 3;
          }else{
           _germ[i][j] = (int)(Math.random() * 2);
          }          
         }
        }      
    }
   
    /**
     * 将矩阵_germ[][]边缘值改为3
     */
    public void changeEdge(int[][] _germ){
     
        for (int i = 0; i<_germ.length; i++){
         
         for (int j = 0; j<_germ[i].length; j++){
          if(i == 0||i == _germ.length-1||j == 0||j == _germ[i].length-1){
           _germ[i][j] = 3;
          }         
         }
        }      
    }
   
    /**
     * 输出整个矩阵的值
     */   
    public void output(int[][] _germ){
     
     for (int i = 0; i<_germ.length; i++){
         
         for (int j = 0; j<_germ[i].length; j++){
          
          System.out.print (_germ[i][j] + " ");
         }
         System.out.println ();
        }
    }
   
    /**
     * 输出矩阵_germ[i][j]位置的值
     */
    public int outItem(int[][] _germ,int i,int j){
      return _germ[i][j];
    }
    
    /**
     * 判断当前_germ[i][j]位置的值
     */   
    public boolean itemCurrent(int[][] _germ,int i,int j){
     
     
     if(outItem(_germ,i,j)==0){
      if(itemAround0(_germ,i,j)){
       return true;
      }else{
          return false;
      }
     }else{
      if(itemAround1(_germ,i,j)){
       return true;
      }else{
       return false;
      }
     }
    }
   
    /**
     * 如果当前_germa[i][j]位置为真的话，则_germb[i][j]位置的值为1,否则为0
     */
    public void itemGermB(int[][] _germa,int[][] _germb,int i,int j){
     if(itemCurrent(_germa,i,j)){
      _germb[i][j] = 1;
     }else{
      _germb[i][j] = 0;
     }
    }
    
    /**
     * 判断0周围的环境
     */
    public boolean itemAround0(int[][] _germ,int i,int j){
     if(item0ExistAround1(_germ,i,j)){
      return true;
     }else{
      return false;
     }
     
    }
   
    /**
     * 判断1周围的环境
     */
    public boolean itemAround1(int[][] _germ,int i,int j){
     if(itemExist0NotAll0(_germ,i,j)){
      return true;
     }else{
      return false;
     }     
    }
   
    /**
     * 判断0周围是否满足条件：有1,并且1的位置为true
     * 如果成立，返回true，否则返回flase
     */
    public boolean item0ExistAround1(int[][] _germ,int i,int j){
     if((_germ[i-1][j]==1&&itemExist0NotAll0(_germ,i-1,j))
        ||(_germ[i+1][j]==1&&itemExist0NotAll0(_germ,i+1,j))
        ||_germ[i][j-1]==1&&itemExist0NotAll0(_germ,i,j-1)
        ||_germ[i][j+1]==1&&itemExist0NotAll0(_germ,i,j+1)){
      return true;
     }else{
      return false;
     }
    }
   
    /**
     * 判断1周围是否满足条件：周围除了3之外的数有0但不全是0
     * 如果条件成立，返回true,否则返回false
     */
    public boolean itemExist0NotAll0(int[][] _germ,int i,int j){
     
     int[] a = new int[4];     
     creatArr(_germ,a,i,j);
     int not3 = numArrnot3(a);
     int[] b = new int[not3];
     arrAtoB(a,b);
     
     if((!judgAll0(b))&&(!judgAll1(b))){
      return true;
     }else{
      return false;
     }
     
    }
   
    /**
     * 将germ[i][j]上下左右的数放入一个数组arr[]中
     * 并将不为3的数放入数组arrT[]
     */
    public void creatArr(int[][] _germ,int[] arr,int i,int j){
     
     arr[0] = _germ[i-1][j];
     arr[1] = _germ[i+1][j];
     arr[2] = _germ[i][j-1];
     arr[3] = _germ[i][j+1];
     
    }
   
    /**
     * 返回数组arr[]中不为3的代码的个数
     */   
    public int numArrnot3(int[] arr){
     
     int not3 = 0;
     for (int i = 0; i<arr.length; i++){
      if(arr[i]!=3){
       not3++;
      }
     }
     return not3;
     
    }
   
    /**
     * 把数组arrA[]中所有不为3的数放入数组arrB[] 中
     */
    public void arrAtoB(int[] arrA,int[] arrB){
     int arrLong = 0;
     for (int i = 0; i<arrA.length; i++){
      if(arrA[i] != 3){
       arrB[arrLong] = arrA[i];
       arrLong++;
      }
     }
    }

    /**
     * 判断数组中是否全为0，如果是，返回true,否则返回false
     */
    public boolean judgAll0(int[] _arr){
     int numItm = 0;
     for (int i = 0; i<_arr.length; i++){
      if(_arr[i] == 0){
       numItm++;
       
      }
     }
     if(numItm == _arr.length){
      return true;
     }else{
      return false;
     }
    } 
   
    /**
     * 判断数组中是否全为1，如果是，返回true,否则返回false
     */
    public boolean judgAll1(int[] _arr){
     int numItm = 0;
     for (int i = 0; i<_arr.length; i++){
      if(_arr[i] == 1){
       numItm++;
       
      }
     }
     if(numItm == _arr.length){
      return true;
     }else{
      return false;
     }
    }
   
    /**
     * 将矩阵germa和germb交换位置
     */   
    public void changeAB(){
      int[][] _germtemp;
      _germtemp = germa;
      germa = germb;
      germb = _germtemp;
    }       
}

新建一个Test类：
/**
 * @(#)Test.java
 *
 *
 * @author LiuJie
 * @version 1.00 2007/4/13
 */

public class Test {

    public Test() {
    }
   
    public static void main (String[] args) {
     
     int acount = 0;
     int num = 10;//循环次数
     Germ g1 = new Germ();
     g1.initialize(g1.germa);
     g1.output(g1.germa);
     System.out.println ("*****************");
     
        while(true){
     
      for (int i = 1; i<g1.germa.length-1; i++){
       for (int j = 1; j<g1.germa[i].length-1; j++){
        g1.itemGermB(g1.germa,g1.germb,i,j);
       }
      }
      g1.changeEdge(g1.germb);
      g1.changeAB();
      g1.output(g1.germa);     
      acount++;
      System.out.println ("————————————————" + acount);
      if(acount > num-1 ){
       break;
      }  
     }
    }  
   
}

完成^_^
注意把两个java文件放到一个文件夹里。