Java 面向对象编程：抽象类与继承的应用（猫狗案例）

本教程将通过猫和狗的案例，演示 Java 中抽象类和继承的概念，并提供详细的代码实现，以及测试类验证结果。

需求：

分析猫类和狗类，找到两者共性，抽取一个父类，并用继承的方式编写一个父类 (Animal)，两个子类：猫类 (Cat) 和狗类 (Dog)；

分析：

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

思路：

定义一个包 domain。
定义父类 Animal 为抽象类，包含以下内容：
- 成员变量：姓名 name，年龄 age
- 构造方法：无参、全参
- 成员方法：get/set 方法
- 抽象方法：吃饭()
定义猫类 Cat，继承 Animal 类，包含以下内容：
- 成员属性：可爱度 lovely
- 构造方法：无参、全参
- 成员方法：抓老鼠()
- 重写吃饭() 方法，输出“' + getName() + ' is eating fish.”
定义狗类 Dog，继承 Animal 类，包含以下内容：
- 成员属性：体重 weight
- 构造方法：无参、全参
- 成员方法：看门()
- 重写吃饭() 方法，输出“' + getName() + ' is eating meat.”
定义测试类，并添加一个测试方法，分别实例化猫和狗的对象，并输出结果。

代码：

Animal 类代码：

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 abstract void eat();

    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;
    }
}

Cat 类代码：

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;
    }

    @Override
    public void eat() {
        System.out.println(getName() + " is eating fish.");
    }

    public void catchMouse() {
        System.out.println(getName() + " is catching mouse.");
    }

    public int getLovely() {
        return lovely;
    }

    public void setLovely(int lovely) {
        this.lovely = lovely;
    }
}

Dog 类代码：

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;
    }

    @Override
    public void eat() {
        System.out.println(getName() + " is eating meat.");
    }

    public void watch() {
        System.out.println(getName() + " is watching.");
    }

    public double getWeight() {
        return weight;
    }

    public void setWeight(double weight) {
        this.weight = weight;
    }
}

测试类代码：

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

public class AnimalTest {
    public static void main(String[] args) {
        Cat cat = new Cat("Tom", 2, 90);
        Dog dog = new Dog("Jerry", 3, 10.5);

        System.out.println("猫的姓名：" + cat.getName());
        System.out.println("猫的年龄：" + cat.getAge());
        System.out.println("猫的可爱度：" + cat.getLovely());
        cat.eat();
        cat.catchMouse();

        System.out.println("狗的姓名：" + dog.getName());
        System.out.println("狗的年龄：" + dog.getAge());
        System.out.println("狗的体重：" + dog.getWeight());
        dog.eat();
        dog.watch();
    }
}

输出结果：

猫的姓名：Tom
猫的年龄：2
猫的可爱度：90
Tom is eating fish.
Tom is catching mouse.
狗的姓名：Jerry
狗的年龄：3
狗的体重：10.5
Jerry is eating meat.
Jerry is watching.

总结：

通过本案例，我们学习了 Java 中抽象类和继承的概念，以及如何利用它们来实现代码复用和扩展。抽象类定义了共性行为，子类继承父类并实现抽象方法，从而展现出各自的个性化行为。这种面向对象编程的思想可以提高代码的可维护性和可扩展性。