Java 多态实现猫狗案例：代码示例与测试

使用多态编写猫狗案例：代码示例与测试

需求：

分析猫类和狗类，找到它们的共性内容，抽取出一个父类，用继承的方式编写一个父类 (Animal)，两个子类：猫类 (Cat) 和狗类 (Dog)。

分析：

• 猫类：
  • 成员变量：姓名，年龄
  • 构造方法：无参、全参
  • 成员方法：get/set 方法、吃饭()、抓老鼠()
• 狗类：
  • 成员变量：姓名，年龄
  • 构造方法：无参、全参
  • 成员方法：get/set 方法、吃饭()、看门()

共性：

• 姓名，年龄、无参、全参、get/set 方法、吃饭() 方法

思路：

1. 定义一个包 domain；
2. 定义父类 Animal 为抽象类：
   • 成员变量：姓名 name，年龄 age
   • 构造方法：无参、全参
   • 成员方法：get/set 方法
   • 抽象方法：吃饭()；
3. 定义猫类 Cat，继承 Animal 类：
   • 成员属性：可爱度 lovely
   • 构造方法：无参、全参
   • 成员方法：抓老鼠()、重写吃饭() {…}
4. 定义狗类 Dog，继承 Animal 类：
   • 成员属性：体重 weight
   • 构造方法：无参、全参
   • 成员方法：看门()、重写吃饭() {…}
5. 定义测试类，并添加一个测试方法，分别实例化猫和狗的对象，并输出结果。

代码：

//Animal.java

package domain;

public abstract class Animal {
    private String name; //姓名
    private int age; //年龄
    
    public Animal() {
    }
    
    public Animal(String name, int age) {
        this.name = name;
        this.age = age;
    }
    
    public String getName() {
        return name;
    }
    
    public void setName(String name) {
        this.name = name;
    }
    
    public int getAge() {
        return age;
    }
    
    public void setAge(int age) {
        this.age = age;
    }
    
    public abstract void eat(); //吃饭的抽象方法
}

//Cat.java

package domain;

public class Cat extends Animal {
    private int lovely; //可爱度
    
    public Cat() {
    }
    
    public Cat(String name, int age, int lovely) {
        super(name, age);
        this.lovely = lovely;
    }
    
    public int getLovely() {
        return lovely;
    }
    
    public void setLovely(int lovely) {
        this.lovely = lovely;
    }
    
    public void catchMouse() {
        System.out.println(getName() + '正在抓老鼠');
    }
    
    @Override
    public void eat() {
        System.out.println(getName() + '正在吃鱼');
    }
}

//Dog.java

package domain;

public class Dog extends Animal {
    private double weight; //体重
    
    public Dog() {
    }
    
    public Dog(String name, int age, double weight) {
        super(name, age);
        this.weight = weight;
    }
    
    public double getWeight() {
        return weight;
    }
    
    public void setWeight(double weight) {
        this.weight = weight;
    }
    
    public void watchDoor() {
        System.out.println(getName() + '正在看门');
    }
    
    @Override
    public void eat() {
        System.out.println(getName() + '正在吃骨头');
    }
}

//Test.java

package test;

import domain.Animal;
import domain.Cat;
import domain.Dog;

public class Test {
    public static void main(String[] args) {
        Animal cat = new Cat('Tom', 2, 80);
        Animal dog = new Dog('Jack', 3, 20.5);
        
        cat.eat();
        ((Cat) cat).catchMouse();
        System.out.println(cat.getName() + '的可爱度为：' + ((Cat) cat).getLovely());
        
        System.out.println();
        
        dog.eat();
        ((Dog) dog).watchDoor();
        System.out.println(dog.getName() + '的体重为：' + ((Dog) dog).getWeight());
    }
}

//输出结果如下：

Tom正在吃鱼
Tom正在抓老鼠
Tom的可爱度为：80

Jack正在吃骨头
Jack正在看门
Jack的体重为：20.5

总结：

该示例通过 Java 多态性实现了猫和狗的不同行为，展示了面向对象编程中的重要概念，如继承、抽象类、方法重写等。通过这种方式，我们可以更好地组织代码，提高代码的可复用性和可维护性。