你的想法不错，但是程序逻辑有点混乱，按你的思路随手写了个，注释还算比较全吧
创新互联公司坚持“要么做到，要么别承诺”的工作理念，服务领域包括：成都网站设计、做网站、成都外贸网站建设公司、企业官网、英文网站、手机端网站、网站推广等服务，满足客户于互联网时代的平定网站设计、移动媒体设计的需求，帮助企业找到有效的互联网解决方案。努力成为您成熟可靠的网络建设合作伙伴！
子兔子和父兔子只要一个类就能表示，都可以抽象为兔子，并没有实质区别，兔子里面有属性：父兔子对象、子兔子List、是否死了、出生月数
我没有处理超出Integer类型范围的异常，死期初始定为Integer.MAX_VALUE，即不会死
/**
* Rabbit.java
*/
import java.util.ArrayList;
import java.util.List;
/**
* 兔子
*
* @author Shawn
* @date Jun 30, 2013
*/
public class Rabbit {
/**
* 多少月可以生兔子（包括此月）
*/
static final int RABBIT_BORN = 3;
/**
* 多少月兔子会死，假设到此月兔子生下后代之后才死，值不小于RABBIT_BORN
*/
static final int RABBIT_DEATH = Integer.MAX_VALUE;
/**
* 父兔子
*/
private Rabbit parent;
/**
* 出生后有多少月
*/
private Integer month;
/**
* 死了没
*/
private Boolean isDead;
/**
* 子兔子
*/
private ListRabbit sons = new ArrayListRabbit();
public Rabbit(Rabbit parent, Integer month) {
this.parent = parent;
this.month = month;
if (month = RABBIT_DEATH) {
this.isDead = true;
} else {
this.isDead = false;
}
setSons();
}
private void setSons() {
if (month = RABBIT_BORN) {
// 如果死了则按死期计算，否则按当前月数计算
int canBreedMonth = isDead ? RABBIT_DEATH - RABBIT_BORN + 1 : month
- RABBIT_BORN + 1;
for (int i = 0; i canBreedMonth; i++) {
Rabbit son = new Rabbit(this, month - RABBIT_BORN - i);
sons.add(son);
}
}
}
public Integer getMonth() {
return month;
}
public Rabbit getParent() {
return parent;
}
public Boolean isDead() {
return isDead;
}
public ListRabbit getSons() {
return sons;
}
}
/**
* RabbitTree.java
*/
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
/**
* 兔子的生成树，非必要
* 其实只从一个根Rabbit对象就可计算出所有兔子个数
* 此类作用是格式化兔子树，便于获取树的各种属性
*
* @author Shawn
* @date Jun 30, 2013
*/
public class RabbitTree {
/**
* 此后只计算有多少对兔子
*/
static final int RABBIT_PAIR = 2;
/**
* 多少月
*/
private int month;
/**
* 存储整颗树，外层Map表示层次，内层List为每层的兔子
*/
private MapInteger, ListRabbit rabbitMap = new HashMapInteger, ListRabbit();
/**
* 构造函数，输入月份（包括此月）
*
* @param month
*/
public RabbitTree(int month) {
if (month = 0) {
throw new IllegalArgumentException("月数不正确");
}
this.month = month;
// 祖先兔子，从此兔子即可获取整颗树结构
Rabbit ancestor = new Rabbit(null, month);
initTree(ancestor);
}
/**
* 树的初始化
*
* @param rabbit
*/
private void initTree(Rabbit rabbit) {
ListRabbit currentLevel = new ArrayListRabbit();
ListRabbit nextLevel = rabbit.getSons();
currentLevel.add(rabbit);
//处理根节点
rabbitMap.put(1, currentLevel);
Integer count = 2;
ListRabbit sons = new ArrayListRabbit();
sons.addAll(nextLevel);
//处理叶节点
while (sons.size() != 0) {
currentLevel = new ArrayListRabbit();
nextLevel = new ArrayListRabbit();
for (Rabbit r : sons) {
currentLevel.add(r);
for (Rabbit e : r.getSons()) {
nextLevel.add(e);
}
}
sons = new ArrayListRabbit();
sons.addAll(nextLevel);
rabbitMap.put(count, currentLevel);
count++;
}
}
/**
* 获得树上兔子总数
*
* @return
*/
public int getRabbitNum() {
int count = 0;
for (Integer level : rabbitMap.keySet()) {
ListRabbit list = rabbitMap.get(level);
for (Rabbit r : list) {
if (!r.isDead()) {
count++;
}
}
}
return count * RABBIT_PAIR;
}
/**
* 获取树的高度
*
* @return
*/
public int getLevel() {
return rabbitMap.size();
}
/**
* 获取树的月数
*
* @return
*/
public int getMonth() {
return month;
}
public static void main(String[] args) {
RabbitTree tree = new RabbitTree(10);
System.out.println(tree.getRabbitNum());
}
}
这道题目考察的是运用递归(数列)的思路去解决问题。
假设到第24个月，示例代码如下：
public class woo {
public static void main(String args[]) {
System.out.println(fib(24));
}
private static int fib(int n) {
if (n == 1 || n == 2) {
return 1;
} else {
return fib(n - 1) + fib(n - 2);
}
}
}
扩展资料：
斐波那契数列（Fibonacci sequence），又称黄金分割数列、因数学家列昂纳多·斐波那契（Leonardoda Fibonacci）以兔子繁殖为例子而引入，故又称为“兔子数列”，指的是这样一个数列：1、1、2、3、5、8、13、21、34、……。
在数学上，斐波纳契数列以如下被以递推的方法定义：F(1)=1，F(2)=1, F(n)=F(n-1)+F(n-2)在现代物理、准晶体结构、化学等领域，斐波纳契数列都有直接的应用，为此，美国数学会从1963年起出版了以《斐波纳契数列季刊》为名的一份数学杂志，用于专门刊载这方面的研究成果。
参考资料：
百度百科：斐波那契数列
百度百科：递归函数
还是耐着性子给你做完了望采纳。。。
第七题
/**
* 动物抽象类
*/
public abstract class Animal {
//颜色
private String color;
//类别
private String type;
//吃饭
public abstract void eat();
//叫
public abstract void cry();
//get set方法省略。。。
}
/**
* 游泳的接口
*/
public interface Swimable {
//游泳
public void swim();
}
/**
* 兔子类
*/
public class Rabbit extends Animal {
@Override
public void eat() {
System.out.println("小兔几吃萝卜。。。");
}
@Override
public void cry() {
System.out.println("小兔几呵呵哒。。。");
}
}
/**
* 青蛙类
*/
public class Frog extends Animal implements Swimable {
public void swim() {
System.out.println("青蛙会蛙泳。。。");
}
@Override
public void eat() {
System.out.println("青蛙吃昆虫。。。");
}
@Override
public void cry() {
System.out.println("青蛙呱呱叫。。。");
}
}
public class Test {
public static void main(String[] args) {
//兔子
Rabbit rabbit = new Rabbit();
rabbit.eat();
rabbit.cry();
//青蛙
Frog frog = new Frog();
frog.eat();
frog.cry();
frog.swim();
}
}
第八题
/**
* 学生类
*/
public class Student {
//学号
private String id;
//姓名
private String name;
//性别
private char gender;
//年龄
private int age;
public Student(String id, String name, char gender, int age) {
this.id = id;
this.name = name;
this.gender = gender;
this.age = age;
}
//获得学号、姓名、性别、年龄
public String toString() {
return "学号："+id +" 姓名：" + name + " 性别：" + gender + " 年龄：" + age;
}
//修改年龄
public void changeAge(int range) {
age = range;
}
//get set方法省略。。。
}
public class Test {
public static void main(String[] args) {
Student s = new Student("alibb008", "杰克马", '公', 18) ;
System.out.println(s.toString());
s.changeAge(50);
System.out.println(s.toString());
}
}
感慨啊。。。
public class Test {//用递归法计算兔子的规律
static long fib(int x){
if(x2) return (fib(x-1)+fib(x-2));
else return 1;
}
public static void main(String[] args) {
for(int i=1;i=24;i++){
long n=fib(i);
//算出的是对数.要算总数的法,*2就行
System.out.println("第"+i+"个月有兔子对数为"+n);
}
}
}
1、单行(single-line)--短注释：//……
单独行注释：在代码中单起一行注释，
注释前最好有一行空行，并与其后的代码具有一样的缩进层级。如果单行无法完成，则应采用块注释。
注释格式：/*
注释内容
*/
行头注释：在代码行的开头进行注释。主要为了使该行代码失去意义。
注释格式：//
注释内容
行尾注释：尾端(trailing)--极短的注释，在代码行的行尾进行注释。一般与代码行后空8（至少4）个格，所有注释必须对齐。
注释格式：代码
+
8（至少4）个空格
+
//
注释内容
2、块(block)--块注释：/*……*/
注释若干行，通常用于提供文件、方法、数据结构等的意义与用途的说明，或者算法的描述。一般位于一个文件或者一个方法的前面，起到引导的作用，也可以根据需要放在合适的位置。这种域注释不会出现在HTML报告中。注释格式通常写成：
/*
*
注释内容
*/
3、文档注释：/**……*/
注释若干行，并写入javadoc文档。每个文档注释都会被置于注释定界符
/**......*/
...
import java.awt.*; // 导入相应的awt工具组件
import java.awt.event.*;// 导入awt工具组件的事件类
/**
* 作用：Calc类用于演示加法计算器的功能p
* @author 网络用户
* @version 1.0 2009-6-3
* @since JDK 1.5
*/
class Calc extends WindowAdapter implements ActionListener
{
//以下声明相关变量
Frame f; //窗口
// Button b0,b1,b2,b3,b4,b5,b6,b7,b8,b9;
Button b[] = new Button[10]; //10个按钮，分别对应数字0到9
Button be, badd, bc; //bc为=，badd为+，bc为归0按钮
TextField answer; //文本框answer用于显示相加的结果
Panel p; //面板
int t1, t2,result; //t1,t2分别表示被加数，加数
Button bmin, bmul, bdev; //bmin为-，bmul为*，bdev为/
String op1 = null,lastOP = null;
boolean isOK = true;
/**
* 作用：main方法为程序运行的入口
* @param args
*/
public static void main( String args[] )
{
Calc cg = new Calc(); //创建一个calc类的对象
cg.go(); //调用go方法，显示加法器界面，并完成加法功能
}
/**
* 作用：go()方法用于显示加法器界面，并完成加法功能
*/
public void go()
{
p = new Panel(); //创建面板的对象，10个按钮将在此面板对象上添加和显示
answer = new TextField("0", 15); //设置文本框的默认值为0，文本框的长度15个字符
b[0] = new Button("0"); //以下就是那10个按钮，按钮上的文本就是0到9的数字
b[1] = new Button("1");
b[2] = new Button("2");
b[3] = new Button("3");
b[4] = new Button("4");
b[5] = new Button("5");
b[6] = new Button("6");
b[7] = new Button("7");
b[8] = new Button("8");
b[9] = new Button("9");
be = new Button("="); //=号
badd = new Button("+"); //+号
bc = new Button("C"); //归0按钮
bmin = new Button("-"); //-号
bmul = new Button("*"); //*号
bdev = new Button("/"); //除号
p.setLayout(new GridLayout(4, 4)); //将面板设置为4行3列，即12个格子，刚好可以存放地10个数字按钮另加+号按钮和=号按钮，共12个按钮
p.add(b[1]);
p.add(b[2]);
p.add(b[3]);
p.add(b[4]);
p.add(b[5]);
p.add(b[6]);
p.add(b[7]); //添加10个数字按钮到面板上
p.add(b[8]);
p.add(b[9]);
p.add(b[0]);
for( int i = 0; i b.length; i++ )
b[i].addActionListener(this); //为10个数字按钮添加事件监听器，以用于实现加法功能
p.add(be); //添加=号按钮到面板上
p.add(bc); //归0按钮
p.add(badd); //添加+号按钮到面板上
be.addActionListener(this); //为=号按钮添加事件监听器，用于实现加法功能
bc.addActionListener(this); //为归0按钮添加事件监听器，用于将计算结果归0
badd.addActionListener(this); //为+号按钮添加事件监听器，用于实现加法功能
p.add(bmin); //-号
p.add(bmul); //*号
p.add(bdev); //除号
bmin.addActionListener(this);
bmul.addActionListener(this);
bdev.addActionListener(this);
f = new Frame("计算器"); //创建一个Frame对象（窗口），窗口的标题就是calc
f.setLocation(300, 300); //窗口的弹出位置
f.setSize(300, 300); //窗口的大小为300*300像素
f.add(answer, "North"); //将文本框设置在窗口的北部（上），窗口的默认布局为BorderLayout,即东西南北中5个位置
f.add(p, "Center"); //将面板设置在窗口的中部（中）
f.addWindowListener(this); //为窗口添加事件监听器，用于实现关闭窗口的功能
f.pack(); //此方法用于窗口到合适的大小
f.setVisible(true); //显示窗口，为false时将不会显示窗口
}
//在10个数字按钮和3个功能按钮上单击，将触发此方法
public void actionPerformed( ActionEvent e )
{
if( e.getSource() == bc )
{//单击了归0按钮，设置为默认值
result = 0;
lastOP = null ;
answer.setText("0"); //文本框设为0
isOK = true; //已经经过运算了
} else if( e.getSource() == badd || e.getSource() == bmin || e.getSource() == bmul || e.getSource() == bdev ||e.getSource() == be)
{//单击运算符号的按钮
op1 = e.getActionCommand();
getResult(op1);
} else
{//单击0到9之间的任意一个数字按钮
for( int i = 0; i b.length; i++ )
if( e.getSource() == b[i] )
{
if( isOK == true )
{
answer.setText(b[i].getActionCommand());
isOK = false;
}
else
{
answer.setText(answer.getText()+b[i].getActionCommand()); //在文本框上显示连续单击那几个数字
}
}
}
}
/**
* 作用：getResult()方法用于计算出结果值，并在文本框显示出来P
* @param op 本次操作运算符
* @param text
*/
private void getResult( String op )
{
if(answer.getText().equals("除数不能为0"))
{
answer.setText(result+"");
return;
}
if( lastOP==null )
{//没有上一次的操作
if(op.equals("=")){
return;
}else{
result = Integer.parseInt(answer.getText());
}
} else if( lastOP.equals("+") )
{//上一次单击了+号按钮
result = result + Integer.parseInt(answer.getText());
answer.setText(result+""); //文本框设为0
} else if( lastOP.equals("-") )
{//单击-号按钮
result = result - Integer.parseInt(answer.getText());
answer.setText(result+"");//在文本框上显示相加的结果
} else if( lastOP.equals("*") )
{//单击*号按钮
result = result * Integer.parseInt(answer.getText());
answer.setText(result+""); //文本框设为0
} else if( lastOP.equals("/") )
{//单击/号按钮
if(answer.getText().equals("0")) answer.setText("除数不能为0"); //文本框设为0
else{
result = result / Integer.parseInt(answer.getText());
answer.setText(result+""); //文本框设为0
}
}
isOK = true; //已经经过运算了
lastOP = op; //记下本次操作
}
//关闭窗口，触发此方法
public void windowClosing( WindowEvent ev )
{
System.exit(0); //退出程序
}
}
