【JAVA】Java基础—面向对象编程：继承—重写方法使用总结练习

一个简单的练习：创建Animal类及其子类Dog和Cat

假设我正在开发一个动物管理系统，其中有多种动物（如狗、猫等）。我定义一个Animal类，表示所有动物的共性，然后为每种动物创建子类，如Dog和Cat，并在这些子类中重写Animal类的方法，以实现不同动物的特有行为。

下面我通过创建一个Animal类及其子类Dog和Cat来演示重写方法的使用。

步骤 1：创建Animal类

// 定义一个父类 Animal
class Animal {
    // 父类方法，用于发出声音
    public void makeSound() {
        System.out.println("Animal makes a sound");
    }
}

• Animal类：这是一个简单的父类，定义了一个makeSound方法，表示动物发出的声音。这个方法可以被所有动物子类重写，以实现不同的声音效果。

步骤 2：创建Dog子类

// 定义一个子类 Dog 继承自 Animal
class Dog extends Animal {
    // 重写父类的 makeSound 方法
    @Override
    public void makeSound() {
        System.out.println("Dog barks");
    }
}

• Dog类：这是Animal类的子类，重写了makeSound方法。这里我提供了Dog特有的实现，即当调用makeSound时，输出“Dog barks”。

步骤 3：创建Cat子类

// 定义一个子类 Cat 继承自 Animal
class Cat extends Animal {
    // 重写父类的 makeSound 方法
    @Override
    public void makeSound() {
        System.out.println("Cat meows");
    }
}

• Cat类：同样是Animal类的子类，重写了makeSound方法。这里我提供了Cat特有的实现，即当调用makeSound时，输出“Cat meows”。

步骤 4：创建主类进行测试

// 主类
public class Main {
    public static void main(String[] args) {
        // 创建 Animal 类型的引用指向 Dog 对象
        Animal myDog = new Dog();
        myDog.makeSound(); // 输出: Dog barks

        // 创建 Animal 类型的引用指向 Cat 对象
        Animal myCat = new Cat();
        myCat.makeSound(); // 输出: Cat meows
    }
}

1. 主类 Main：在main方法中，我创建了Animal类型的引用，但分别指向Dog和Cat对象。

2. 调用makeSound方法：当我调用makeSound方法时，Java运行时会根据实际对象的类型（Dog或Cat）来决定调用哪个方法，从而展示了多态性。

一个复杂的练习：创建Animal类及其子类Dog和Cat

接下来创建一个更复杂的动物类层次结构，方便大家更好的理解，包含以下内容：

• Animal：抽象类，定义动物的基本特性和行为。

• Dog：继承自Animal，实现特定行为。

• Cat：继承自Animal，实现特定行为。

• Pet：接口，定义宠物的特有行为。

步骤 1：创建Animal抽象类

// 定义一个抽象类 Animal
abstract class Animal {
    // 动物的名称
    private String name;
    
    // 构造方法
    public Animal(String name) {
        this.name = name;
    }
    
    // 抽象方法：动物发出声音
    public abstract void makeSound();
    
    // 获取动物名称
    public String getName() {
        return name;
    }
    
    // 动物移动
    public void move() {
        System.out.println(name + " is moving");
    }
}

• Animal类：这是一个抽象类，包含一个构造方法和两个方法。makeSound是一个抽象方法，子类必须实现。move方法是一个具体方法，所有动物都可以使用。

• name属性：表示动物的名称，通过构造方法初始化。

步骤 2：创建Pet接口

// 定义一个接口 Pet
interface Pet {
    // 宠物的特有行为：玩耍
    void play();
}

• Pet接口：定义了一个方法play，表示宠物可以进行的行为。实现这个接口的类需要提供具体的实现。

步骤 3：创建Dog子类

// 定义一个子类 Dog 继承自 Animal 并实现 Pet 接口
class Dog extends Animal implements Pet {
    // 构造方法
    public Dog(String name) {
        super(name);
    }

    // 重写父类的 makeSound 方法
    @Override
    public void makeSound() {
        System.out.println(getName() + " barks");
    }

    // 实现 Pet 接口的 play 方法
    @Override
    public void play() {
        System.out.println(getName() + " plays fetch");
    }
}

• Dog类：继承自Animal并实现Pet接口。重写了makeSound方法，并实现了play方法，提供了狗的特有行为。

步骤 4：创建Cat子类

// 定义一个子类 Cat 继承自 Animal 并实现 Pet 接口
class Cat extends Animal implements Pet {
    // 构造方法
    public Cat(String name) {
        super(name);
    }

    // 重写父类的 makeSound 方法
    @Override
    public void makeSound() {
        System.out.println(getName() + " meows");
    }

    // 实现 Pet 接口的 play 方法
    @Override
    public void play() {
        System.out.println(getName() + " chases a laser pointer");
    }
}

• Cat类：同样继承自Animal并实现Pet接口。重写了makeSound方法，并实现了play方法，提供了猫的特有行为。

步骤 5：创建主类进行测试

// 主类
public class Main {
    public static void main(String[] args) {
        // 创建 Dog 和 Cat 对象
        Animal myDog = new Dog("Buddy");
        Animal myCat = new Cat("Whiskers");

        // 调用 makeSound 和 move 方法
        myDog.makeSound(); // 输出: Buddy barks
        myDog.move();      // 输出: Buddy is moving
        ((Pet) myDog).play(); // 输出: Buddy plays fetch

        myCat.makeSound(); // 输出: Whiskers meows
        myCat.move();      // 输出: Whiskers is moving
        ((Pet) myCat).play(); // 输出: Whiskers chases a laser pointer
    }
}

1. 主类 Main：在main方法中，创建了Dog和Cat对象，分别赋值给Animal类型的引用。

2. 调用方法：调用了makeSound和move方法，展示了重写的效果。同时，通过类型转换将Animal引用转换为Pet接口，以调用play方法，展示了接口的使用。