弎问笔录28 之 狐狸和兔子（一）

最新推荐文章于 2024-09-05 10:39:00 发布
最新推荐文章于 2024-09-05 10:39:00 发布
阅读量199 收藏 1
点赞数
文章标签： java python
原文链接：https://my.oschina.net/u/2559261/blog/591427
版权

2019独角兽企业重金招聘Python工程师标准>>> hot3.png

按计划本来是昨天就应该写好发上来的了，可是突然遭遇感冒，头疼疼的就耽搁了，不好意思啊 ，今天大步赶上，^_^;

游戏规则是这样的：

  1. 狐狸和兔子都有年龄，到了一定年龄死掉；

  2. 狐狸可以随机决定吃周围的一只兔子，吃一次年龄上限就会提高一次；

  3. 狐狸和兔子会随机生个baby；

  4. 狐狸和兔子会向周围随机移动；

这个游戏可以看成是细胞自动机游戏的进阶版。游戏窗口是分割成一个个的网格，这些网格里的对象都统一交由一个数据管理类（Field）来管理实现互动，这些互动包括随机移动（move），捕食（feed）,繁殖（breed）。然后这些数据更新好后将会由一个表现类（View）将其画（paint ）出来。狐狸（fox）和（rabbit）对象都会放进网格当中去，因此创建一个接口(ICell)，让狐狸和兔子实现这个接口。这样就可以把狐狸和兔子放进网格里去，并交由Field对象来管理。同时狐狸和兔子都存在共同的特性，例如年龄，都存在年龄上限，都会移动，繁殖等，因此可以创建一个Animal类，并让狐狸和兔子继承（extends）它。

随手画了个结构简图（好粗糙）：

111232_bQei_2559261.jpg

出来一个效果是这样的（红色的是狐狸，黑色的是兔子（红狐黑兔））：105620_IgEV_2559261.jpg

 

package field;
/**
 * 为什么创建Location呢？
 * 因为根据游戏规则，狐狸和兔子会向周围空的位置移动，因此需要一个类来记录周围位置的坐标；
 * @author ItigerU
 *
 */
public class Location {
 private int row;
 private int col;
 public Location(int row, int col) {
  super();
  this.row = row;
  this.col = col;
 }
 public int getRow() {
  return row;
 }
 public int getCol() {
  return col;
 }
}

创建接口，狐狸和兔子通过这个接口放到Field里面去，Field对象通过管理ICell来管理狐狸和兔子：

package ICell;
/**
 * 这个接口只定义了一个方法，就是把让实现了这个接口的子类自己把自己给画出来；
 */
import java.awt.Graphics;
public interface ICell {
 void draw(Graphics g, int x, int y, int size);
}

创建好接口后创建Animal类：

package animal;
import java.util.List;
import field.Location;
/**1. 为什么Animal是抽象类；
 * Animal是狐狸和兔子的父类，实现了共同的属性和方法；例如年龄，年龄上限，移动，捕食，繁殖；
 * 繁殖需要每个子类重写（overridde）,因为狐狸和兔子的繁殖概率不一样。所以将它定义成抽象方法；
 * 所以Animal是抽象类；
 * @author ItigerU
 *
 */
public abstract class Animal {
 private int age;
 private int ageLimit;
 private int breedableAge;
 private boolean isAlive = true;
 //给子类设定年龄上限和生育年龄
 public Animal(int ageLimit, int breedableAge) {
  this.ageLimit = ageLimit;
  this.breedableAge = breedableAge;
 }
 public int getAge() {
  return age;
 }
 public boolean isAlive() {
  return isAlive;
 }
 //该方法用来实现颜色的渐变；
 public double getAgePercent() {
  return (double)age / ageLimit;
 }
 
 public boolean isbreedable() {
  return age >= breedableAge;
 }
 //生长
 public void grow() {
  age ++;
  if(age > ageLimit) {
   this.die();
  }
 }
 //死亡
 public void die() {
  this.isAlive = false;
 }
 //随机繁殖；返回的一定是一个Animal啊...
 public abstract Animal breed();
 //随机移动,返回的是一个位置(确定移动到那个点的位置)。传入某点坐标和周围空的位置；
 public Location move(int row, int col, Location[] freeAdj) {
  Location ret = null;
  if(freeAdj.length > 0 && Math.random() < 0.12) {
   ret = freeAdj[(int)(Math.random() * freeAdj.length)];
  }
  return ret;
 }
 /*
  * 随机捕食；返回的是一个Animal对象，传入的是某点坐标和周围所有（意味着这是容器）的对象；
  * 需要狐狸重写，因为只有狐狸才捕食；
  */
 public Animal feed(int row, int col, List<Animal> fed) {
  return null;
 }
 //根据规则：狐狸每捕食一次年龄上限加一次；
 public void longerLife(int inc) {
  ageLimit += inc;
 }
 
 @Override
 public String toString() {
  return "" + age + " : " + (this.isAlive ? "isAlive" : "dead");
 }
 
}

创建好Animal类后再把狐狸和兔子两个子类给创建好：

package animal;
import java.awt.Color;
import java.awt.Graphics;
import java.util.List;
import ICell.ICell;
public class Fox extends Animal implements ICell {
 public Fox() {
  super(20, 4);
 }
 @Override
 public Animal breed() {
  Animal ret = null;
  if(Math.random() < 0.05) {
   ret = new Fox();
  }
  return ret;
 }
 @Override
 public void draw(Graphics g, int x, int y, int size) {
  int alpha = (int)((1 - this.getAgePercent()) * 255);
  g.setColor(new Color(0, 0, 0, alpha));
  g.fillRect(x, y, size, size);
 }
 //捕食，返回一个Animal.传入该点坐标，周围可捕食的对象；年龄上限加2；
 public Animal feed(int row, int col, List<Animal> feed){
  Animal ret = null;
  if(Math.random() < 0.05) {
   ret = feed.get((int)(Math.random() * feed.size()));
   this.longerLife(2);
  }
  return ret;
 }
 @Override
 public String toString() {
  return "Fox " + super.toString();
 }
}
package animal;
import java.awt.Color;
import java.awt.Graphics;
import ICell.ICell;
public class Rabbit extends Animal implements ICell {
 public Rabbit() {
  super(10, 2);
 }
 @Override
 public void draw(Graphics g, int x, int y, int size) {
  int alpha = (int)((1 - this.getAgePercent()) * 255);
  g.setColor(new Color(255, 0, 0, alpha));
  g.fillRect(x, y, size, size);
 }
 @Override
 public Animal breed() {
  Animal ret = null;
  if(Math.random() < 0.12) {
   ret = new Rabbit();
  }
  return ret;
 }
 @Override
 public String toString() {
  return "Rabbit: " + super.toString();
 }
}

第一个可以看到是Fox，第二个是Rabbit，它们之间差不多，但是Fox重写feed（）方法，Rabbit没有。因为按游戏规则，Rabbit没有吃的说法，因此当调用Rabbit去feed的时候，是调用了父类的feed（）方法，此时返回一个null；

接下来把Field给码上：

package field;
import java.util.ArrayList;
import java.util.List;
import ICell.ICell;
public class Field {
 private int height;
 private int width;
 private ICell[][] cells;
 /*
  * 1. adjacent为什么要将它设置为静态常量呢？
  */
 private static final Location[] adjacent = {
   new Location(-1, 1),new Location(0, 1),new Location(1, 1),
   new Location(-1, 0),new Location(0, 0),new Location(0, 1),
   new Location(-1, -1),new Location(0, -1),new Location(-1, -1)
 };
 public Field(int height, int width) {
  this.height = height;
  this.width = width;
  cells = new ICell[height][width];
 }
 public int getHeight() {
  return height;
 }
 public int getWidth() {
  return width;
 }
 public ICell get(int row, int col) {
  return cells[row][col];
 }
 public ICell place(int row, int col, ICell cell) {
  ICell ret = cells[row][col];
  cells[row][col] = cell;
  return ret;
 }
// public ICell[] getNeighbour(int row, int col) {
//  List<ICell> list = new ArrayList<ICell>();
//  for(int i = -1; i < 2; i ++) {
//   for(int j = -1; j < 2; j ++) {
//    int r = row + i;
//    int c = col + j;
//    if(r > -1 && r < height && c > -1 && c < width && !(r == row && c == col)) {
//     list.add(cells[r][c]);
//    }
//   }
//  }
//  return list.toArray(new ICell[list.size()]);
// }
 public ICell[] getNeighbour(int row, int col) {
  List<ICell> list = new ArrayList<ICell>();
  for(Location loc : adjacent) {
   int r = row + loc.getRow();
   int c = col + loc.getCol();
   if(r > -1 && r < height && c > -1 && c < width && !(r == row && c == col)) {
    list.add(cells[r][c]);
   }
  }
  return list.toArray(new ICell[list.size()]);
 }
 public Location[] getFreeAdj(int row, int col) {
  List<Location> list = new ArrayList<Location>();
  for(Location loc : adjacent) {
   int r = row + loc.getRow();
   int c = col + loc.getCol();
   if(r > -1 && r < height && c > -1 && c < width && (cells[r][c] == null)) {
    list.add(new Location(r, c));
   }
  }
  return list.toArray(new Location[list.size()]);
 }
 //给指定的对象在指定的位置附近随机放置；需要返回什么吗？不需要返回什么；
 public void placeRandomAdj(int row, int col, ICell cell) {
  Location[] loc = this.getFreeAdj(row, col);
  if(loc.length > 0) {
   int index = (int)(Math.random() * loc.length);
   cells[loc[index].getRow()][loc[index].getCol()] = cell;
  }
 }
 public ICell remove(int row, int col) {
  ICell ret = cells[row][col];
  cells[row][col] = null;
  return ret;
 }
 public void remove(ICell cell) {
  for(int row = 0; row < height; row ++) {
   for(int col = 0; col < width; col ++) {
    if(cells[row][col] == cell) {
     cells[row][col] = null;
     break;
    }
   }
  }
 }
 //将指定的对象移动到指定的地方
 public void move(int row, int col, Location loc) {
  cells[loc.getRow()][loc.getCol()] = cells[row][col];
  remove(row, col);
 }
}

现在是表现类View：

package field;
import java.awt.Dimension;
import java.awt.Graphics;
import javax.swing.JPanel;
import ICell.ICell;
public class View extends JPanel {
 private static final int GIRD_SIZE = 16;
 private Field field;
 
 public View(Field field){
  this.field = field;
 }
 
 @Override
 public void paint(Graphics g) {
  super.paint(g);
  for(int row = 0; row < field.getHeight(); row ++) {
   g.drawLine(0, row * GIRD_SIZE, field.getWidth() * GIRD_SIZE, row * GIRD_SIZE);
  }
  for(int col = 0; col < field.getHeight(); col ++) {
   g.drawLine( col * GIRD_SIZE, 0, col * GIRD_SIZE, field.getHeight() * GIRD_SIZE);
  }
  for(int row = 0; row < field.getHeight(); row ++) {
   for(int col = 0; col < field.getWidth(); col ++) {
    ICell cell  = field.get(row, col);
    if(cell != null) {
     cell.draw(g, col, row, GIRD_SIZE);
    }
   }
  }
 }
 
 @Override
 public Dimension getPreferredSize() {
  return new Dimension(field.getWidth() * GIRD_SIZE + 1, field.getHeight() * GIRD_SIZE + 1);
 }
}

现在我们已经把整个程序中的功能类已经完成了，现在通过引入更高层次的类去实现它们之间的一个通信，这个，我们就将在下一篇当中去详细展开~

转载于:https://my.oschina.net/u/2559261/blog/591427

weixin_33973609
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
中国大学MOOC 翁恺 Java进阶课 狐狸与兔子代码
03-28
翁恺老师在mooc上Java进阶课程 狐狸和兔子 的代码，从这里刚开始讲接口，需要的同学可以自行下载
翁恺老师 狐狸和兔子练习
qq_41939099的博客
05-15 1700
习题描述 狐狸、兔子都有年龄； 到达一定年龄上限会自然死亡； 狐狸随机吃掉周围一只兔子； 狐狸、兔子可以随机生一只小的放在旁边格子； 如果不吃不生，狐狸、兔子可以随机向旁边格子移一步会随机吃掉 Animal抽象类 animal抽象类是fox，rabbit的父类： 属性：ageLimit(生存时间)，breedableAge(生育年龄)，age(现年龄)，isAlive； 方法： **构造方法：**生存时间、生育年龄； **简单方法：**获取年龄、年龄百分比、成长(到年龄死亡)、见耶稣、确定没死、确定能生、寿
兔子洞问题
08-15
围绕着山顶有10个圆形排列的洞，狐狸要吃兔子，兔子说：“可以，但必须先找到我，我就藏身于这十个洞中的某个洞。你从第１个洞找，下次隔１个洞（即2号洞）找，第三次隔２个洞（即5号洞）找，再隔3个…以后在这个圆圈中如此类推，次数不限。”但狐狸从早到晚进进出出了1000次，仍没有找到兔子。 问兔子究竟藏在几号洞里？
狐狸找兔子在哪里？C语言
08-11
围绕着山顶有10个圆形排列的洞，狐狸要吃兔子，兔子说：“可以，但必须先找到我，我就藏身于这十个洞中的某个洞。你从１号洞找，下次隔１个洞（即3号洞）找，第三次隔２个洞（即6号洞）找，再隔3个…以后在这个圆圈中如此类推，次数不限。”但狐狸从早到晚进进出出了1000次，仍没有找到兔子。
狐狸与兔子，代码解析
weixin_43688665的博客
07-31 1419
看懂代码从main函数开始 这是主类 package foxnrabbit; import java.util.ArrayList; import javax.swing.JFrame; import field.Field; import field.View; import field.Location; import animal.Animal; import animal.Fox; import animal.Rabbit; import cell.Cell; public class
狐狸和兔子围绕山洞c语言,弎问笔录30 之 狐狸和兔子（二）
weixin_35653679的博客
05-19 217
现在把FoxAndRabbit给码出来：packagefoxnrabbit;importjava.util.ArrayList;importjava.util.List;importjavax.swing.JFrame;importICell.ICell;importanimal.Animal;importanimal.Fox;importanimal.Rabbit;import...
linux系列之常用运维命令整理笔录
热门推荐
Nicky's blog
11-02 33万+
本博客记录工作中需要的linux运维命令，大学时候开始接触linux，会一些基本操作，可是都没有整理起来，加上是做开发，不做运维，有些命令忘记了，所以现在整理成博客，当然vi，文件操作等就不介绍了，慢慢积累一些其它拓展的命令，博客不定时更新 free -m 其中：m表示兆，也可以用g，注意都要小写 Men：表示物理内存统计 total：表示物理内存总数(total=used+free) use......
智能笔录系统.pptx
07-01
市场产品现状 侦查询问笔录 产品现状 笔录的历史记录缺乏有效利用， 区域内的笔录不能共享 笔录生成缺乏法律库、经验库实时指导 笔录信息不能及时与公安业务 实时对接缺乏实战性 笔录记录时，人工打字效率慢 智能...
破产清算组询问笔录.pdf
03-10
在破产清算组询问笔录中，时间和地点是非常重要的信息，因为它们可以帮助确定询问的发生时间和地点，从而确保询问的合法性和公正性。被询问人和询问人是询问过程中的主要参与方，被询问人是提供信息的人，而询问人则...
搜查笔录示例之欧阳理创编.pdf
10-07
搜查笔录示例之欧阳理创编.pdf
现场勘验检查笔录(范文).pdf
10-24
标题中提到的“现场勘验检查笔录”是一种正式的法律文件，它详细记录了警方或调查人员在犯罪现场所进行的勘查和检查活动。在司法程序中，现场勘验检查笔录作为证据的一部分，对案件的调查和审理起着至关重要的作用。...
提取痕迹物证登记表现场勘验笔录附件一.pdf
10-08
提取痕迹物证登记表、现场勘验笔录及相关附件是刑事侦查中的重要环节，涉及到的技术主要包括现场勘查技术、物证管理、证据分析和法律程序。这些文档主要用于记录、管理和分析犯罪现场的证据，以帮助确定犯罪事实、...
Java 接口(interface)的用途和好处
maijia0754的博客
10-12 1249
Java 接口(interface)的用途和好处
C++经典问题：狐狸找兔子
weixin_34168700的博客
09-28 1361
问题描述： 围绕着山顶有10个洞，一只狐狸和一只兔子住在各自的洞里。狐狸想吃掉兔子。一天，兔子对狐狸说：“你想吃我有一个条件，先把洞从1－10编上号，你从10号洞出发，先到1号洞找我；第二次隔1个洞找我，第三次隔2个洞找我，以后依次类推，次数不限，若能找到我，你就可以饱餐一顿。不过在没有找到我以前不能停下来。”狐狸满口答应，就开始找了。它从早到晚进了1000次洞，累得昏了过去，也没找到兔...
C语言小练习——围绕着山顶有10个圆形排列的洞，狐狸要吃兔子（运行结果截图在最下面）
Coder Rookie
08-03 6830
/* * 围绕着山顶有10个圆形排列的洞，狐狸要吃兔子 * ，兔子说：“可以，但必须先找到我，我就藏身 * 于这十个洞中的某个洞。你从1号洞找，下次隔 * 1个洞（即3号洞）找，第三次隔2个洞（即6号洞 * ）找，再隔3个…以后在这个圆圈中如此类推，次 * 数不限。”但狐狸从早到晚进进出出了1000次，仍 * 没有找到兔子。 * * 问：兔子可能藏身于哪（几）个洞中？ *...
【JavaWeb】JDBC&Druid&Tomcat入门使用
lklalmq的博客
09-04 1050
预编译SQL语句并执行：预防SQL注入问题获取 PreparedStatement 对象// SQL语句中的参数值，使用？占位符替代?// 通过Connection对象获取，并传入对应的sql语句设置参数值上面的sql语句中参数使用?进行占位，在之前之前肯定要设置 这些?的值。PreparedStatement对象：setXxx(参数1，参数2)：给?赋 值Xxx：数据类型；如 setInt (参数1，参数2)参数：参数1：？的位置编号，从1 开始参数2：？的值执行SQL语句。
JAVA基础：数据类型、命名规范
最新发布
weixin_53755148的博客
09-05 1280
变量类型就是用来指定变量中存储数据的类型。也称为数据类型。
java 笔录在线编辑导入导出
02-07
Java笔录在线编辑导入导出是指利用Java语言开发的在线编辑工具，可以实现笔录的编辑、导入和导出功能。 首先，Java笔录在线编辑工具可以让用户通过网页的方式编辑笔录内容，无需安装任何软件，只需一个支持Java的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值