【JavaSE专栏63】多态，父类引用子类的对象，面向对象编程中的重要概念

Designer 小郑

发布于 2023-08-02 08:20:54

51500

代码可运行

文章被收录于专栏：跟着小郑学JAVA跟着小郑学JAVA

运行总次数：0

代码可运行

作者主页：Designer 小郑 作者简介：3年JAVA全栈开发经验，专注JAVA技术、系统定制、远程指导，致力于企业数字化转型，CSDN学院、蓝桥云课认证讲师。 主打方向：Vue、SpringBoot、微信小程序

本文讲解了 Java 中面向对象多态的概念及语法，并给出了样例代码。多态是面向对象编程中的一个重要概念，它允许使用父类的引用变量来引用子类的对象，实现对不同子类对象的统一处理。

一、什么是多态

多态是面向对象编程中的一个重要概念，它允许使用父类的引用变量来引用子类的对象，实现对不同子类对象的统一处理。

在 Java 中，多态性可以通过继承和方法的重写来实现。当一个父类引用变量指向一个子类对象时，可以通过这个父类引用变量调用子类中重写的方法。

多态性的好处在于它能够通过统一的父类接口，实现对不同子类对象的调用和处理，这样可以提高代码的灵活性、可扩展性和可维护性。

举个例子，假设有一个动物类 Animal 和它的两个子类 Dog 和 Cat。

Animal类中有一个 eat() 方法，而 Dog 和 Cat 类中分别重写了这个方法。

通过多态性，可以使用 Animal 类型的引用变量来引用 Dog 或 Cat 对象，然后通过这个引用变量调用 eat() 方法，程序会根据实际引用的对象类型来自动选择相应的方法进行调用。

class Animal {
    public void eat() {
        System.out.println("Animal is eating.");
    }
}

class Dog extends Animal {
    @Override
    public void eat() {
        System.out.println("Dog is eating.");
    }
}

class Cat extends Animal {
    @Override
    public void eat() {
        System.out.println("Cat is eating.");
    }
}

public class Main {
    public static void main(String[] args) {
        Animal animal1 = new Dog();
        Animal animal2 = new Cat();
        
        animal1.eat();  // 输出: Dog is eating.
        animal2.eat();  // 输出: Cat is eating.
    }
}

在上面的例子中，animal1 和 animal2 都是 Animal 类型的引用变量，但它们分别指向了 Dog 和 Cat 对象。虽然它们的类型是 Animal，但在运行时会根据实际引用的对象类型来调用相应的方法，实现了多态性。

二、为什么要多态

Java 中多态的存在有以下

个好处，请同学们认真学习。

灵活性：多态使得代码更加灵活和可扩展。通过使用父类的引用变量来引用不同子类的对象，可以实现对不同对象的统一处理，从而提高了代码的灵活性。
可替换性：多态性使得代码更具有可替换性。由于父类引用变量可以引用子类的对象，所以可以在不改变代码的情况下，替换成不同的子类对象，从而实现了代码的可替换性。
统一接口：多态性使得代码具有统一的接口。通过父类定义的接口和方法，可以在多个子类中共享，并且通过父类引用变量来调用这些方法，从而实现了代码的统一接口，使得程序设计更加规范和统一。
代码重用：多态性通过继承的机制实现了代码的重用。子类可以继承父类的属性和方法，从而避免了重复编写相同的代码，提高了代码的复用性。
扩展性：多态性使得代码更具有可扩展性。通过继承和重写父类的方法，子类可以在父类的基础上进行功能的扩展，添加新的属性和方法，从而实现了代码的扩展性。

通过合理地应用多态性，可以设计出结构清晰、可扩展、可维护的代码，提高开发效率和代码质量。多态性是面向对象编程中的一个重要特性，它能够提高代码的灵活性和可扩展性，使得程序设计更加符合面向对象的原则。

三、如何进行多态

在 Java 中，实现多态的基础是继承和方法的重写，下面是一个简单的示例代码来说明多态的实现，请同学们认真学习。

// 父类 Animal
class Animal {
    public void eat() {
        System.out.println("Animal is eating.");
    }
}

// 子类 Dog
class Dog extends Animal {
    @Override
    public void eat() {
        System.out.println("Dog is eating.");
    }
}

// 子类 Cat
class Cat extends Animal {
    @Override
    public void eat() {
        System.out.println("Cat is eating.");
    }
}

public class Main {
    public static void main(String[] args) {
        Animal animal1 = new Dog(); // 父类引用指向子类对象
        Animal animal2 = new Cat(); // 父类引用指向另一个子类对象

        animal1.eat(); // 调用重写后的方法，输出：Dog is eating.
        animal2.eat(); // 调用重写后的方法，输出：Cat is eating.
    }
}

在上面的示例中，Animal 是父类，而 Dog 和 Cat 是子类。父类 Animal 中有一个 eat() 方法，而子类 Dog 和 Cat 分别重写了这个方法。

在 Main 类的 main() 方法中，通过Animal类型的引用变量 animal1 和 animal2 来引用 Dog 和 Cat 对象。

animal1 和 animal2 虽然是 Animal 类型的引用变量，但它们指向的实际上是 Dog 和 Cat 对象。

当调用 animal1.eat() 和 animal2.eat() 时，由于这两个引用变量分别指向了不同的子类对象，所以会根据实际引用的对象类型来调用相应的重写方法。