第三周练习题：题目一

• 题目一 :（60分）

1. 案例题目描述:   

 现有鸡类和猫类，它们有共同的属性：编号、年龄、姓名、腿数；它们有共同的行为：吃饭（但是猫吃鱼、鸡吃小米）。另外，鸡还可以下蛋，猫还可以捉老鼠。下面根据上述题意结合接口和抽象类的特点创建抽象动物类，创建对应的接口。

其他要求：

1. 鸡类还需要定义一个特有的静态成员变量（count）;用于记录目前为止这群鸡一共下了多少个鸡蛋；每当调用一次鸡的下蛋方法count++;
2. 在测试类中实例化2个猫对象，3个鸡对象（使用多态形式）
3. 调用猫捉老鼠方法，调用鸡的下蛋方法
4. 输出目前一共下了几个鸡蛋
5. 测试类中创建一个Animal数组，将上述5个对象存入数组中
6. 定义一个方法用于统计共有多少条腿：参数是Animal数组；返回值是int类型
7. 定义一个方法用于输出动物的年龄最大：参数是Animal数组；返回值是int类型
8. 定义一个方法用于求出这个数组中所有的动物的平均年龄：参数是Animal数组；返回值是double类型。
9. 在测试类中分别调用上述3种方法

1. 评分标准：

1. 按要求创建抽象父类(5分)

   package com.xu.lx3;
   /**
    * 题目一：动物抽象类
    * */
   public abstract class Animal {
       //创建共同属性
       private int id;//编号
       private int age;//年龄
       private String name;//姓名
       private int legs;//腿数
       //创建共同方法
       public abstract void eat();
       //创建默认构造
       public Animal() {
       }
       //创建带参构造
       public Animal(int id, int age, String name, int legs) {
           this.id = id;
           this.age = age;
           this.name = name;
           this.legs = legs;
       }
   
       public int getId() {
           return id;
       }
   
       public void setId(int id) {
           this.id = id;
       }
   
       public int getAge() {
           return age;
       }
   
       public void setAge(int age) {
           this.age = age;
       }
   
       public String getName() {
           return name;
       }
   
       public void setName(String name) {
           this.name = name;
       }
   
       public int getLegs() {
           return legs;
       }
   
       public void setLegs(int legs) {
           this.legs = legs;
       }
   }
   

2. 按要求创建下蛋接口(5分

   package com.xu.lx3;
   /**
    * 鸡下蛋接口
    * */
   public interface IEgg {
       void  egg();
   }
   

3. 按要求创建捉老鼠接口(5分)

   package com.xu.lx3;
   /**
    * 猫捉老鼠接口
    * */
   public interface IZuo {
        void zuo();
   }
   

4. 按要去创建猫类继承抽象父类，实现捉老鼠接口（5分）

   package com.xu.lx3;
   /**
    * 猫类
    * */
   public class Cat extends Animal implements IZuo {
   
       @Override
       public void eat() {
           System.out.println("猫吃鱼......");
       }
       //猫还可以捉老鼠
       public void zuo(){
           System.out.println("猫捉老鼠......");
       }
   
       public Cat() {
       }
   
       public Cat(int id, int age, String name, int legs) {
           super(id, age, name, legs);
       }
   }
   

5. 按要去创建鸡类继承抽象父类，实现下蛋接口（5分）

   package com.xu.lx3;
   /**
    * 鸡类
    * */
   public class Chicken extends Animal implements IEgg {
       //鸡类还需要定义一个特有的静态成员变量（count）;
   //用于记录目前为止这群鸡一共下了多少个鸡蛋；
       private static int count;
       @Override
       public void eat() {
           System.out.println("鸡吃小米......");
       }
       //鸡还可以下蛋
       //每当调用一次鸡的下蛋方法count++;
   
       public void egg(){
           System.out.println("鸡在下蛋.....");
           count++;
           System.out.println("下了"+count+"个鸡蛋");
       }
       //创建默认构造
       public Chicken() {
       }
       //创建带参构造
       public Chicken(int id, int age, String name, int legs) {
           super(id, age, name, legs);
       }
   
       public static int getCount() {
           return count;
       }
   
       public static void setCount(int count) {
           Chicken.count = count;
       }
   }
   

6. 编写测试类，多态形式创建对象并存入数组中（5分）
7. 调用下蛋和捉老鼠方法（5分）
8. 输出共下了多少个鸡蛋（5分）
9. 编写统计共有多少条腿方法(5分)
10. 编写用于输出最大年龄的动物方法(5分)
11. 编写求动物的平均年龄方法(5分)
12. 分别调用上述3个方法(腿数,最大年龄,平均年龄)（5分）

    package com.xu.lx3;
    /**
     * 动物测试类
     * */
    public class TestAnimal {
    
        public static void main(String[] args) {
            //(2)在测试类中实例化2个猫对象，3个鸡对象（使用多态形式）
            Animal cat1=new Cat(1,3,"小花",4);
            Animal cat2=new Cat(2,4,"小白",4);
            Animal ck1=new Chicken(3,2,"贝贝",2);
            Animal ck2=new Chicken(4,5,"星星",2);
            Animal ck3=new Chicken(5,1,"点点",2);
            //(3)调用猫捉老鼠方法，调用鸡的下蛋方法//(4)输出目前一共下了几个鸡蛋
            if(cat1 instanceof Cat){//判断是否在猫类
                ((Cat) cat1).zuo();
            }
            if(cat2 instanceof IZuo){//判断是否实现接口
                ((Cat) cat2).zuo();
            }
            if(ck1 instanceof Chicken){
                ((Chicken) ck1).egg();
            }
            if(ck2 instanceof IEgg){
                ((Chicken) ck2).egg();
            }
            if(ck3 instanceof Chicken){
                ((Chicken) ck3).egg();
            }
    
            //(5)测试类中创建一个Animal数组，
            // 将上述5个对象存入数组中
            Animal[] an={cat1,cat2,ck1,ck2,ck3};
            //调用计算腿数量方法
            int disp=TestAnimal.disp(an);
            System.out.println("腿是数量是"+disp);
            //调用最大年龄方法
            int maxAge=TestAnimal.maxAge(an);
            System.out.println("最大年龄为"+maxAge);
            //调用动物的平均年龄方法
            double avg=TestAnimal.avgAge(an);
            System.out.println("动物的平均年龄为"+avg);
        }
    
    
    
        //(6)定义一个方法用于统计共有多少条腿：
        // 参数是Animal数组；返回值是int类型
        public static int disp(Animal[] ans){
            int sum=0;
            for(Animal an: ans){
                sum+=an.getLegs();
            }
            return sum;
        }
        //(7)定义一个方法用于输出动物的年龄最大：
        // 参数是Animal数组；返回值是int类型
        public static int maxAge(Animal[] ans){
            int max=ans[0].getAge();
            for (int i=0;i<ans.length;i++){
                if (ans[i].getAge()>max){
                    max=ans[i].getAge();
                }
            }
            return max;
        }
        //(8)定义一个方法用于求出这个数组中所有的动物的平均年龄：
        // 参数是Animal数组；返回值是double类型。
        public static double avgAge(Animal[] ans){
            double avg=0;
            for (Animal an:ans){
                avg+=an.getAge();
            }
            return avg/ans.length;
        }
    }