Java OOP 教程：继承与多态实验

介绍

在本实验中，我们将探索 Java 面向对象编程中的两个基本概念：继承（inheritance）和多态（polymorphism）。这些强大的功能使我们能够创建更有组织性、高效且灵活的代码。我们将从继承开始，它使我们能够基于现有类创建新类，然后继续探讨多态，它允许我们以统一的方式处理不同类的对象。

在本实验结束时，你将能够：

使用继承创建类层次结构
在子类中重写方法
理解并使用多态
实现抽象类和抽象方法

如果这些术语听起来复杂，请不要担心——我们会将所有内容分解为简单易懂的步骤。让我们开始这段激动人心的旅程，提升你的 Java 编程技能吧！

创建基类

我们将从创建一个名为 Animal 的基类开始。这个类将作为我们其他类的基础。

打开终端并导航到你的项目目录：
```
cd ~/project
```
使用 touch 命令创建一个名为 Animal.java 的新文件：
```
touch Animal.java
```
在文本编辑器中打开 Animal.java 并添加以下代码：
```
public class Animal {
    private String name;
    private int age;

    public Animal(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public void eat() {
        System.out.println(name + " is eating.");
    }

    public void sleep() {
        System.out.println(name + " is sleeping.");
    }

    public String getName() {
        return name;
    }

    public int getAge() {
        return age;
    }
}
```
让我们分解一下这段代码：
- 我们定义了一个名为 Animal 的类，它有两个属性：name（一个字符串）和 age（一个整数）。
- private 关键字表示这些属性只能在类内部访问。
- 我们有一个构造函数，在创建 Animal 对象时初始化这些属性。
- 我们有两个方法：eat() 和 sleep()，它们打印动物正在做什么。
- 我们还有“getter”方法（getName() 和 getAge()），允许我们从类外部访问私有属性。
保存 Animal.java 文件。
现在，让我们编译 Animal 类以确保没有错误。在终端中运行：
```
javac Animal.java
```
如果没有错误消息，说明你的类编译成功了！

创建子类

现在我们已经有了基础的 Animal 类，让我们创建一个名为 Dog 的子类。这将演示 Java 中继承的工作原理。

在你的终端中，创建一个名为 Dog.java 的新文件：
```
touch Dog.java
```
在你的文本编辑器中打开 Dog.java，并添加以下代码：
```
public class Dog extends Animal {
    private String breed;

    public Dog(String name, int age, String breed) {
        super(name, age);  // 调用超类构造函数
        this.breed = breed;
    }

    public String getBreed() {
        return breed;
    }
}
```
让我们分解一下这段新代码：
- extends Animal 告诉 Java，Dog 是 Animal 的一个子类。虽然 Dog 继承自 Animal，但 Animal 中的私有属性 name 和 age 在 Dog 中是不可直接访问的。然而，Dog 可以通过继承的公共 getter 方法 getName() 和 getAge() 访问这些属性。
- 我们添加了一个新的属性 breed，该属性是 Dog 特有的。
- 构造函数接受三个参数。它使用 super(name, age) 来调用 Animal 构造函数，然后设置 breed。
- 我们添加了一个新的方法 getBreed()，该方法是 Dog 特有的。
保存 Dog.java 文件。
编译 Dog 类：
```
javac Dog.java
```
你可能会看到关于 Animal.class 的警告，但现在没关系。

演示继承

现在我们已经有了 Animal 和 Dog 类，接下来让我们创建一个程序来演示继承的工作原理。

创建一个名为 InheritanceDemo.java 的新文件：
```
touch InheritanceDemo.java
```

打开 InheritanceDemo.java 并添加以下代码：

public class InheritanceDemo {
    public static void main(String[] args) {
        Animal genericAnimal = new Animal("Generic Animal", 5);
        Dog myDog = new Dog("Buddy", 3, "Labrador");

        System.out.println("Demonstrating Animal class:");
        genericAnimal.eat();
        genericAnimal.sleep();

        System.out.println("\nDemonstrating Dog class:");
        myDog.eat();  // 从 Animal 继承
        myDog.sleep();  // 从 Animal 继承

        System.out.println("\nDog details:");
        System.out.println("Name: " + myDog.getName());  // 继承的方法
        System.out.println("Age: " + myDog.getAge());  // 继承的方法
        System.out.println("Breed: " + myDog.getBreed());  // Dog 特有的方法
    }
}

这个程序创建了 Animal 和 Dog 类的实例，并演示了 Dog 类如何从 Animal 类继承方法。

保存 InheritanceDemo.java 文件。

编译并运行程序：

javac InheritanceDemo.java
java InheritanceDemo

你应该会看到类似以下的输出：

Demonstrating Animal class:
Generic Animal is eating.
Generic Animal is sleeping.

Demonstrating Dog class:
Buddy is eating.
Buddy is sleeping.

Dog details:
Name: Buddy
Age: 3
Breed: Labrador

这个演示展示了 Dog 类如何从 Animal 类继承属性和方法，同时还添加了自己特有的属性（breed）和方法（getBreed()）。

方法重写

方法重写（Method Overriding）是一个允许子类为其父类中已定义的方法提供特定实现的功能。让我们看看它是如何工作的。

打开 Dog.java 并添加以下方法：
```
@Override
public void eat() {
    System.out.println(getName() + " is eating dog food.");
}
```
将此方法添加到 Dog 类中，但不要放在其他方法内部。

@Override 注解告诉编译器我们打算重写父类中的方法。它不是必需的，但使用它是一个良好的实践。
保存 Dog.java 文件。

现在，让我们修改 InheritanceDemo.java 来演示方法重写。打开 InheritanceDemo.java 并将其内容替换为：

public class InheritanceDemo {
    public static void main(String[] args) {
        Animal genericAnimal = new Animal("Generic Animal", 5);
        Dog myDog = new Dog("Buddy", 3, "Labrador");

        System.out.println("Demonstrating method overriding:");
        genericAnimal.eat();
        myDog.eat();

        System.out.println("\nDemonstrating inherited method:");
        myDog.sleep();  // 这个方法仍然继承自 Animal

        System.out.println("\nDog details:");
        System.out.println("Name: " + myDog.getName());
        System.out.println("Age: " + myDog.getAge());
        System.out.println("Breed: " + myDog.getBreed());
    }
}

保存 InheritanceDemo.java 文件。

编译并运行更新后的程序：

javac Animal.java Dog.java InheritanceDemo.java
java InheritanceDemo

方法重写输出示例

你应该会看到类似以下的输出：

Demonstrating method overriding:
Generic Animal is eating.
Buddy is eating dog food.

Demonstrating inherited method:
Buddy is sleeping.

Dog details:
Name: Buddy
Age: 3
Breed: Labrador

这个示例展示了方法重写如何允许 Dog 类为 eat() 方法提供自己的实现，同时仍然继承 Animal 类中的其他方法，例如 sleep()。

多态简介

多态（Polymorphism）是面向对象编程中的一个基本概念，它允许我们使用基类引用来引用子类对象。这使得代码更加灵活和可重用。让我们看看它是如何工作的。

创建一个名为 Cat.java 的新文件：
```
touch Cat.java
```

打开 Cat.java 并添加以下代码：

public class Cat extends Animal {
    public Cat(String name, int age) {
        super(name, age);
    }

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

    public void meow() {
        System.out.println(getName() + " says: Meow!");
    }
}

这创建了 Animal 的另一个子类，它有自己的 eat() 方法和一个新的 meow() 方法。

保存 Cat.java 文件。

现在，让我们更新 InheritanceDemo.java 来演示多态。将其内容替换为：

public class InheritanceDemo {
    public static void main(String[] args) {
        Animal[] animals = new Animal[3];
        animals[0] = new Animal("Generic Animal", 5);
        animals[1] = new Dog("Buddy", 3, "Labrador");
        animals[2] = new Cat("Whiskers", 2);

        System.out.println("Demonstrating polymorphism:");
        for (Animal animal : animals) {
            animal.eat();  // 这将为每个动物调用适当的 eat() 方法
        }

        System.out.println("\nAccessing specific methods:");
        ((Dog) animals[1]).getBreed();  // 我们需要强制转换为 Dog 以调用 Dog 特有的方法
        ((Cat) animals[2]).meow();      // 我们需要强制转换为 Cat 以调用 Cat 特有的方法
    }
}

这段代码创建了一个 Animal 对象数组，但实际上我们在其中存储了 Animal、Dog 和 Cat 对象的混合。当我们对每个动物调用 eat() 时，Java 会根据对象的实际类型自动调用适当的方法版本。

保存 InheritanceDemo.java 文件。

编译并运行更新后的程序：

javac Animal.java Dog.java Cat.java InheritanceDemo.java
java InheritanceDemo

你应该会看到类似以下的输出：

Demonstrating polymorphism:
Generic Animal is eating.
Buddy is eating dog food.
Whiskers is eating fish.

Accessing specific methods:
Whiskers says: Meow!

这展示了多态的实际应用。我们能够将所有对象视为 Animal 对象，但当我们调用 eat() 方法时，每个对象都会根据其特定类的实现行为。

总结

在本实验中，我们探索了 Java 面向对象编程的一些关键概念：

继承（Inheritance）：我们创建了一个基类 Animal，并从中派生出 Dog 和 Cat 类。这使得我们能够重用代码并创建逻辑上的类层次结构。
方法重写（Method Overriding）：我们看到了子类如何为父类中定义的方法提供自己的实现，从而实现更具体的行为。
多态（Polymorphism）：我们学习了如何通过共同的父类统一处理不同类的对象，从而使代码更加灵活和可重用。

这些概念是 Java 以及面向对象编程的基础。它们使我们能够创建更有组织性、高效且灵活的代码结构。随着你在 Java 学习中的深入，你会发现这些概念在更复杂的应用中被广泛使用。

记住，练习是掌握这些概念的关键。

Java 继承与多态

介绍

创建基类

创建子类

演示继承

方法重写

多态简介

总结