一头母牛在3—10岁的时候每年可以生一头小牛，生公牛和母牛的比率是50%，在牛12岁的时候就送入屠宰场买了。现在有一个农夫有1头1岁大的母牛，在母牛3岁的时候就送到附近的农场去配种，请问40年后这个农夫可能会有多少头牛，写出相关的代码或答题思路，最好用面向对象。

1. package exercises;
   
2. 
   
3. import java.util.ArrayList;
   
4. import java.util.Iterator;
   
5. import java.util.List;
   
6. import java.util.ListIterator;
   
7. import java.util.Random;
   
8. 
   
9. public class OtherCattle {
   
10. 
    
11.         /**一头母牛在3—10岁的时候每年可以生一头小牛，生公牛和母牛的比率是50%，在牛12岁的时候就送入屠宰场买了。现在有一个农夫有1头1岁大的母牛，
    
12.          * 在母牛3岁的时候就送到附近的农场去配种，请问40年后这个农夫可能会有多少头牛，写出相关的代码或答题思路，最好用面向对象。
    
13.          * @param args
    
14.          */
    
15.         public static void main(String[] args) {
    
16.                 System.out.println(new CattleField().getCount(13));
    
17.         }
    
18.         /*程序随机性比较强,我用测试语句测试到40时,发现有误.如果有兴趣,可以自行更改.因为他没有一个固定的值,公/母是随机的.
    
19.          */
    
20. 
    
21. }
    
22. class CattleField{//牛场,可以做得更形象,一个牛场,一个牛类,因为程序大体已经出来了.但是要学的东西多了,就不细分了.程序做出来就行了.
    
23.         private int age=1;//如果是牛类,可以再加一个姓名属性,这样可以在下面程序中形象的打印,某某牛生什么性别的崽,叫什么,然后某某牛大于12,该去死了.
    
24.         private String sex;
    
25.         private int num;//隐含的牛编号
    
26.         public static int cattleCount=1;
    
27.         private static List<CattleField> cattle=new ArrayList<CattleField>();
    
28.         CattleField(){
    
29.                 cattle.add(new CattleField(1,"母"));//农夫的第一头母牛
    
30.         }
    
31.         CattleField(int age,String sex){
    
32.                 this.num=cattleCount++;
    
33.                 this.age=age;
    
34.                 this.sex=sex;
    
35.         }
    
36.         public CattleField ageIncrease(){//年龄增加
    
37.                         this.age++;
    
38.                 return this;
    
39.         }
    
40.         public String getSex(){//获得新生牛的性别
    
41.                 if(new Random().nextInt(2)>0)
    
42.                         return "公";
    
43.                 else return "母";
    
44.         }
    
45.         public  int getCount(int n){//获取多少年后,牧场的牛数
    
46.                 while(n>0){
    
47.                         /*for (ListIterator<CattleField> in = cattle.listIterator(); in.hasNext();) {//每过一年,牧场的牛,母牛超过3岁要生产,大于12的要挂掉
    
48.                                 CattleField cte=in.next();
    
49.                                 if (cte.sex == "母" && cte.age > 2) {
    
50.                                         in.add(new CattleField(0, getSex()));// 出生了一头牛,性别是随机的
    
51.                                         cattleCount++;
    
52.                                 }
    
53.                                 if(cte.age==12){//大于12岁,就让它去死;
    
54.                                         in.remove();
    
55.                                 }
    
56.                                 cte.age++;
    
57.                                 cte=in.previous();
    
58.                                 in.set(cte);//这里替掉一下集合内的元素
    
59.                         }*/
    
60.                         //不用迭代器,涉及到修改元素时,有些费劲.直接用set与get来玩.
    
61.                         for(int i=0;i<cattle.size();i++){
    
62.                                 if (cattle.get(i).sex == "母" && cattle.get(i).age > 2) {
    
63.                                         cattle.add(new CattleField(0, getSex()));// 出生了一头牛,性别是随机的
    
64.                                 }
    
65.                                 if(cattle.get(i).age==12){//大于12岁,就让它去死;
    
66.                                         System.out.println("第:"+cattle.remove(i).age+"头牛挂了");
    
67.                                         cattleCount--;
    
68.                                 }
    
69.                                 //让每头牛的年龄都增加
    
70.                                 CattleField tempCattle=cattle.get(i).ageIncrease();
    
71.                                 cattle.set(i,tempCattle);
    
72.                         }
    
73.                         System.out.println(cattle);
    
74.                         n--;//年数减点;
    
75.                 }
    
76.                 /*for(Iterator<CattleField> in=cattle.iterator();in.hasNext();){
    
77.                         
    
78.                 }*/
    
79.                 return cattle.size();//这里我返回这个数量有误,不找原因了.返回集合却是对的.
    
80.         }
    
81.         public String toString(){
    
82.                 return "第"+this.num+"头"+this.sex+"牛"+"年龄为:"+this.age;
    
83.         }
    
84. }

复制代码

package com.polaris.test;

import java.util.*;

public class ComputeCattleNum {
// 保存所有母牛
private static List<Cattle> cows = new ArrayList<Cattle>();
// 保存所有当前农夫拥有的牛
private static List<Cattle> cattles = new ArrayList<Cattle>();
public static void main(String[] args) {      
// 第一头母牛
Cattle cow = new Cattle(0,3);
  cows.add(cow);
// 40年
for(int i=0;i<40;++i) {
  // 大于等于12岁的牛送到屠宰场卖掉；同时每年，所有的牛
for(int j=0;j<cattles.size();++j) {
Cattle temp = cattles.get(j);
if(temp.getDead()) {
cattles.remove(temp);
}
  // 开始只有一头母牛，年龄不生长
  if(i>0) { cattles.get(j).grow();
}
  }
// 母牛生小牛
for(int j=0;j<cows.size();++j) {
Cattle calf = cows.get(j).bear();
if(calf!=null) { if(calf.getSex()==0)
    cows.add(calf);  
cattles.add(calf);  
}
}
}
System.out.println("40年后农夫拥有" + cattles.size() + "头牛");   
}
}

58.class Cattle {
// 牛的雌雄：0代表雌，1代表雄
private int sex;
// 牛的年龄
private int age;
// 是否卖掉（已死）  private boolean dead = false;   
public Cattle(int sex, int age) {
this.sex = sex;  this.age = age;
  }
//生出的小牛
public Cattle bear() {
Cattle calf = null;
if(this.sex==0) {
if(this.age>=3 && this.age<=10) {
calf = new Cattle(random(),0);
} else {
//System.out.println("抱歉，此牛太小或太老，不能生育。");
}
} else {
//System.out.println("有没有搞错，公牛也想让它生小牛？");
}
return calf;
}
// 长大一岁，如果当前大于等于12岁，则卖掉
public void grow() {
if(this.age>=12) dead = true;
else this.age++;  }
public int getSex() {
return this.sex;
}
public boolean getDead() {
return this.dead;

}
}

我的程序结果在2 万左右，小至数千，多至5 ，6 万，不知合理不、

解决这个问题要用到 数据结构与算法的知识，感觉要学习好算法，

给出的代码如下，可以验证一下对不对

1. package excise;
   
2. 
   
3. import java.util.ArrayList;
   
4. import java.util.List;
   
5. 
   
6. /**
   
7. * 问题描述：
   
8. *  
   
9. * 一头母牛在3—10岁的时候每年可以生一头小牛，生公牛和母牛的比率是50%，
   
10. * 在牛12岁的时候就送入屠宰场买了。现在有一个农夫有1头1岁大的母牛，
    
11. * 在母牛3岁的时候就送到附近的农场去配种，请问40年后这个农夫可能会有多少头牛，
    
12. * 写出相关的代码或答题思路，最好用面向对象。
    
13. *
    
14. */
    
15. 
    
16. public class ComputeCattles {
    
17.         // 保存所有母牛
    
18.         private static List<Cattle> cows = new ArrayList<Cattle>();
    
19. 
    
20.         // 保存所有当前农夫拥有的牛
    
21.         private static List<Cattle> cattles = new ArrayList<Cattle>();
    
22. 
    
23.         public static void main(String[] args) {
    
24.                 // 第一头母牛
    
25.                 Cattle cow = new Cattle(0, 3);
    
26.                 cows.add(cow);
    
27. 
    
28.                 for (int i = 0; i < 40; ++i) {                // 40年
    
29.                         // 每年，所有的牛，大于等于12岁的牛送到屠宰场卖掉
    
30.                         for (int j = 0; j < cattles.size(); ++j) {
    
31.                                 Cattle temp = cattles.get(j);
    
32.                                 if (temp.getDead()) {
    
33.                                         cattles.remove(temp);
    
34.                                 }
    
35.                                 // 所有牛都在长
    
36.                                 cattles.get(j).grow();
    
37.                         }
    
38. 
    
39.                         // 一头母牛生一头小牛
    
40.                         for (int j = 0; j < cows.size(); ++j) {
    
41.                                 Cattle calf = cows.get(j).bear();
    
42.                                 if (calf != null) {
    
43.                                         if (calf.getSex() == 0)
    
44.                                                 cows.add(calf);
    
45.                                         cattles.add(calf);
    
46.                                 }
    
47.                         }
    
48.                 }
    
49.                 System.out.println("40年后农夫可能拥有" + cattles.size() + "头牛");
    
50.         }
    
51. }
    
52. 
    
53. class Cattle {
    
54.         private int sex;
    
55.         private int age;
    
56. 
    
57.         private boolean dead = false;
    
58. 
    
59.         public Cattle() {
    
60.         }
    
61. 
    
62.         public Cattle(int sex, int age) {
    
63.                 this.sex = sex;
    
64.                 this.age = age;
    
65.         }
    
66. 
    
67.         public Cattle bear() {
    
68.                 Cattle calf = null;
    
69.                 if (this.sex == 0) {
    
70.                         calf = birth();
    
71.                 }
    
72.                 return calf;
    
73.         }
    
74.        
    
75.         private Cattle birth() {
    
76.                 Cattle calf = null;
    
77.                 if (this.age >= 3 && this.age <= 10) {
    
78.                         calf = new Cattle(random(), 0);
    
79.                 }
    
80.                 return calf;
    
81.         }
    
82. 
    
83.         private int random() {
    
84.                 return (int) Math.round(Math.random());
    
85.         }
    
86. 
    
87.         public void grow() {
    
88.                 this.age++;
    
89.         }
    
90. 
    
91.         public int getSex() {
    
92.                 return this.sex;
    
93.         }
    
94. 
    
95.         public boolean getDead() {
    
96.                 if (this.age >= 12)
    
97.                         dead = true;
    
98.                 return this.dead;
    
99.         }
    
100. 
     
101. }
     

复制代码

面试题？是考试题吧？面试现场让你编程吗？