Java 继承与多态

JavaJavaBeginner
立即练习

💡 本教程由 AI 辅助翻译自英文原版。如需查看原文,您可以 切换至英文原版

介绍

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

在本实验结束时,你将能够:

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

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


Skills Graph

%%%%{init: {'theme':'neutral'}}%%%% flowchart RL java(("`Java`")) -.-> java/DataStructuresGroup(["`Data Structures`"]) java(("`Java`")) -.-> java/ProgrammingTechniquesGroup(["`Programming Techniques`"]) java(("`Java`")) -.-> java/ObjectOrientedandAdvancedConceptsGroup(["`Object-Oriented and Advanced Concepts`"]) java/DataStructuresGroup -.-> java/arrays("`Arrays`") java/ProgrammingTechniquesGroup -.-> java/method_overriding("`Method Overriding`") java/ObjectOrientedandAdvancedConceptsGroup -.-> java/classes_objects("`Classes/Objects`") java/ObjectOrientedandAdvancedConceptsGroup -.-> java/class_attributes("`Class Attributes`") java/ObjectOrientedandAdvancedConceptsGroup -.-> java/class_methods("`Class Methods`") java/ObjectOrientedandAdvancedConceptsGroup -.-> java/oop("`OOP`") java/ObjectOrientedandAdvancedConceptsGroup -.-> java/inheritance("`Inheritance`") java/ObjectOrientedandAdvancedConceptsGroup -.-> java/polymorphism("`Polymorphism`") java/ObjectOrientedandAdvancedConceptsGroup -.-> java/annotation("`Annotation`") subgraph Lab Skills java/arrays -.-> lab-413825{{"`Java 继承与多态`"}} java/method_overriding -.-> lab-413825{{"`Java 继承与多态`"}} java/classes_objects -.-> lab-413825{{"`Java 继承与多态`"}} java/class_attributes -.-> lab-413825{{"`Java 继承与多态`"}} java/class_methods -.-> lab-413825{{"`Java 继承与多态`"}} java/oop -.-> lab-413825{{"`Java 继承与多态`"}} java/inheritance -.-> lab-413825{{"`Java 继承与多态`"}} java/polymorphism -.-> lab-413825{{"`Java 继承与多态`"}} java/annotation -.-> lab-413825{{"`Java 继承与多态`"}} end

创建基类

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

  1. 打开终端并导航到你的项目目录:

    cd ~/project
  2. 使用 touch 命令创建一个名为 Animal.java 的新文件:

    touch Animal.java
  3. 在文本编辑器中打开 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()),允许我们从类外部访问私有属性。
  4. 保存 Animal.java 文件。

    保存 Animal java 文件
  5. 现在,让我们编译 Animal 类以确保没有错误。在终端中运行:

    javac Animal.java

    如果没有错误消息,说明你的类编译成功了!

创建子类

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

  1. 在终端中,创建一个名为 Dog.java 的新文件:

    touch Dog.java
  2. 在文本编辑器中打开 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 DogAnimal 的子类。这意味着 Dog 继承了 Animal 的所有非私有方法和属性。
    • 我们添加了一个新的属性 breed,这是 Dog 特有的。
    • 构造函数接受三个参数。它使用 super(name, age) 调用 Animal 的构造函数,然后设置 breed
    • 我们添加了一个新的方法 getBreed(),这是 Dog 特有的。
  3. 保存 Dog.java 文件。

  4. 编译 Dog 类:

    javac Dog.java

    你可能会看到关于 Animal.class 的警告,但目前这是正常的。

演示继承

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

  1. 创建一个名为 InheritanceDemo.java 的新文件:

    touch InheritanceDemo.java
  2. 打开 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 特有的方法
        }
    }

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

  3. 保存 InheritanceDemo.java 文件。

  4. 编译并运行程序:

    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)是一个允许子类为其父类中已定义的方法提供特定实现的功能。让我们看看它是如何工作的。

  1. 打开 Dog.java 并添加以下方法:

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

    将此方法添加到 Dog 类中,但不要放在其他方法内部。

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

  2. 保存 Dog.java 文件。

  3. 现在,让我们修改 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());
        }
    }
  4. 保存 InheritanceDemo.java 文件。

  5. 编译并运行更新后的程序:

    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)是面向对象编程中的一个基本概念,它允许我们使用基类引用来引用子类对象。这使得代码更加灵活和可重用。让我们看看它是如何工作的。

  1. 创建一个名为 Cat.java 的新文件:

    touch Cat.java
  2. 打开 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() 方法。

  3. 保存 Cat.java 文件。

  4. 现在,让我们更新 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 对象数组,但实际上我们在其中存储了 AnimalDogCat 对象的混合。当我们对每个动物调用 eat() 时,Java 会根据对象的实际类型自动调用适当的方法版本。

  5. 保存 InheritanceDemo.java 文件。

  6. 编译并运行更新后的程序:

    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 面向对象编程的一些关键概念:

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

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

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

您可能感兴趣的其他 Java 教程