深入理解Java中的多态

最新推荐文章于 2025-06-01 15:46:44 发布
最新推荐文章于 2025-06-01 15:46:44 发布
阅读量1.1k 收藏 12
点赞数 14
CC 4.0 BY-SA版权
文章标签： java 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/lyx20020823/article/details/145559149

一、多态的概念

多态（Polymorphism）是面向对象编程（OOP）中的一个核心概念，它允许同一个接口或父类引用不同的底层实现对象。多态的本质是“一个接口，多种实现”，即同一个接口可以被不同的子类实现，而调用代码可以不关心具体的实现细节，只通过接口或父类引用操作对象。

多态分为两种主要形式：

  1. 编译时多态（静态多态）：通过方法重载（Overloading）实现。编译器根据方法的参数列表（参数类型、参数个数）来决定调用哪个方法。

  2. 运行时多态（动态多态）：通过方法覆盖（Overriding）实现。运行时根据对象的实际类型来决定调用哪个方法。

本文将重点探讨运行时多态，因为它在实际开发中更为常见且复杂。

二、运行时多态的实现机制

1. 父类引用指向子类对象

运行时多态的核心在于父类引用指向子类对象。这种机制允许通过父类的引用调用子类的方法，而具体的实现取决于对象的实际类型。

class Animal {
    void speak() {
        System.out.println("Animal speaks");
    }
}

class Dog extends Animal {
    @Override
    void speak() {
        System.out.println("Dog barks");
    }
}

class Cat extends Animal {
    @Override
    void speak() {
        System.out.println("Cat meows");
    }
}

public class Test {
    public static void main(String[] args) {
        Animal myDog = new Dog();
        Animal myCat = new Cat();

        myDog.speak(); // 输出：Dog barks
        myCat.speak(); // 输出：Cat meows
    }
}

在上述代码中：

  • myDog 是 Animal 类型的引用，但实际指向的是 Dog 类型的对象。

  • myCat 是 Animal 类型的引用，但实际指向的是 Cat 类型的对象。

  • 调用 myDog.speak() 和 myCat.speak() 时，运行时会根据对象的实际类型调用 Dog 和 Cat 类中覆盖的 speak 方法。

2. 方法覆盖（Overriding）

方法覆盖是运行时多态的关键。子类可以通过覆盖父类的方法来提供自己的实现。覆盖方法时，子类方法的签名（方法名、参数列表）必须与父类方法完全一致。

class Parent {
    void show() {
        System.out.println("Parent show()");
    }
}

class Child extends Parent {
    @Override
    void show() {
        System.out.println("Child show()");
    }
}

public class Test {
    public static void main(String[] args) {
        Parent obj = new Child();
        obj.show(); // 输出：Child show()
    }
}

 

在上述代码中：

  • obj 是 Parent 类型的引用，但实际指向的是 Child 类型的对象。

  • 调用 obj.show() 时，运行时会调用 Child 类中覆盖的 show 方法

3. 动态绑定（Dynamic Binding）

Java运行时系统通过动态绑定来实现运行时多态。动态绑定是指在运行时根据对象的实际类型来决定调用哪个方法。Java虚拟机（JVM）在运行时检查对象的实际类型，并调用相应的方法。

动态绑定的关键在于：

  • 父类引用指向子类对象时，调用的方法是子类覆盖的方法。

  • 如果子类没有覆盖父类的方法，则调用父类的方法。

class Parent {
    void show() {
        System.out.println("Parent show()");
    }
}

class Child extends Parent {
    @Override
    void show() {
        System.out.println("Child show()");
    }
}

public class Test {
    public static void main(String[] args) {
        Parent obj1 = new Parent();
        Parent obj2 = new Child();

        obj1.show(); // 输出：Parent show()
        obj2.show(); // 输出：Child show()
    }
}

 

 

在上述代码中：

  • obj1 是 Parent 类型的引用，实际指向的是 Parent 类型的对象，调用 obj1.show() 时，运行时会调用 Parent 类中的 show 方法。

  • obj2 是 Parent 类型的引用，实际指向的是 Child 类型的对象，调用 obj2.show() 时，运行时会调用 Child 类中覆盖的 show 方法。

三、多态的高级应用

1. 多态与接口

接口是Java中实现多态的另一种方式。接口允许定义一组方法签名，而具体的实现由实现接口的类提供。通过接口，可以实现更灵活的多态。

interface Animal {
    void speak();
}

class Dog implements Animal {
    @Override
    public void speak() {
        System.out.println("Dog barks");
    }
}

class Cat implements Animal {
    @Override
    public void speak() {
        System.out.println("Cat meows");
    }
}

public class Test {
    public static void main(String[] args) {
        Animal myDog = new Dog();
        Animal myCat = new Cat();

        myDog.speak(); // 输出：Dog barks
        myCat.speak(); // 输出：Cat meows
    }
}

 

在上述代码中：

  • myDog 和 myCat 都是 Animal 接口类型的引用，分别指向 Dog 和 Cat 类型的对象。

  • 调用 myDog.speak() 和 myCat.speak() 时，运行时会调用 Dog 和 Cat 类中实现的 speak 方法。

2. 多态与方法参数

多态还可以应用于方法参数。通过父类引用或接口作为方法参数，可以在运行时传递不同类型的子类对象。

class Animal {
    void speak() {
        System.out.println("Animal speaks");
    }
}

class Dog extends Animal {
    @Override
    void speak() {
        System.out.println("Dog barks");
    }
}

class Cat extends Animal {
    @Override
    void speak() {
        System.out.println("Cat meows");
    }
}

public class Test {
    public static void main(String[] args) {
        Dog myDog = new Dog();
        Cat myCat = new Cat();

        makeAnimalSpeak(myDog);
        makeAnimalSpeak(myCat);
    }

    public static void makeAnimalSpeak(Animal animal) {
        animal.speak();
    }
}

 

在上述代码中：

  • makeAnimalSpeak 方法的参数是 Animal 类型的引用。

  • 调用 makeAnimalSpeak(myDog) 和 makeAnimalSpeak(myCat) 时，运行时会根据对象的实际类型调用 Dog 和 Cat 类中覆盖的 speak 方法。

3. 多态与方法返回值

多态还可以应用于方法的返回值。通过父类引用或接口作为方法的返回值，可以在运行时返回不同类型的子类对象。

class Animal {
    void speak() {
        System.out.println("Animal speaks");
    }
}

class Dog extends Animal {
    @Override
    void speak() {
        System.out.println("Dog barks");
    }
}

class Cat extends Animal {
    @Override
    void speak() {
        System.out.println("Cat meows");
    }
}

public class Test {
    public static void main(String[] args) {
        Animal myDog = getAnimal("dog");
        Animal myCat = getAnimal("cat");

        myDog.speak(); // 输出：Dog barks
        myCat.speak(); // 输出：Cat meows
    }

    public static Animal getAnimal(String type) {
        if ("dog".equals(type)) {
            return new Dog();
        } else if ("cat".equals(type)) {
            return new Cat();
        } else {
            return new Animal();
        }
    }
}

 

在上述代码中：

  • getAnimal 方法的返回值是 Animal 类型的引用。

  • 调用 getAnimal("dog") 和 getAnimal("cat") 时，运行时会返回 Dog 和 Cat 类型的对象。

  • 调用 myDog.speak() 和 myCat.speak() 时，运行时会调用 Dog 和 Cat 类中覆盖的 speak 方法。

四、多态的优势

1. 提高代码的可维护性

多态允许通过父类引用操作子类对象，减少了代码的冗余。通过父类引用，可以统一处理不同类型的子类对象，从而提高代码的可维护性。

class Animal {
    void speak() {
        System.out.println("Animal speaks");
    }
}

class Dog extends Animal {
    @Override
    void speak() {
        System.out.println("Dog barks");
    }
}

class Cat extends Animal {
    @Override
    void speak() {
        System.out.println("Cat meows");
    }
}

public class Test {
    public static void main(String[] args) {
        Animal[] animals = {new Dog(), new Cat()};

        for (Animal animal : animals) {
            animal.speak();
        }
    }
}

 

在上述代码中：

  • animals 数组存储了不同类型的子类对象。

  • 通过父类引用 Animal，可以统一调用 speak 方法，而无需关心具体的子类类型。

2. 提高代码的可扩展性

多态允许在不修改现有代码的情况下，通过添加新的子类来扩展功能。这种设计模式符合开闭原则（对扩展开放，对修改封闭）。

class Animal {
    void speak() {
        System.out.println("Animal speaks");
    }
}

class Dog extends Animal {
    @Override
    void speak() {
        System.out.println("Dog barks");
    }
}

class Cat extends Animal {
    @Override
    void speak() {
        System.out.println("Cat meows");
    }
}

class Bird extends Animal {
    @Override
    void speak() {
        System.out.println("Bird chirps");
    }
}

public class Test {
    public static void main(String[] args) {
        Animal[] animals = {new Dog(), new Cat(), new Bird()};

        for (Animal animal : animals) {
            animal.speak();
        }
    }
}

3. 提高代码的复用性

多态允许通过父类引用操作子类对象，减少了代码的冗余。通过父类引用，可以统一处理不同类型的子类对象，从而提高代码的复用性。

class Animal {
    void speak() {
        System.out.println("Animal speaks");
    }
}

class Dog extends Animal {
    @Override
    void speak() {
        System.out.println("Dog barks");
    }
}

class Cat extends Animal {
    @Override
    void speak() {
        System.out.println("Cat meows");
    }
}

public class Test {
    public static void main(String[] args) {
        Animal myDog = new Dog();
        Animal myCat = new Cat();

        makeAnimalSpeak(myDog);
        makeAnimalSpeak(myCat);
    }

    public static void makeAnimalSpeak(Animal animal) {
        animal.speak();
    }
}

在上述代码中：

  • makeAnimalSpeak 方法的参数是 Animal 类型的引用。

  • 通过父类引用，可以统一调用 speak 方法，而无需关心具体的子类类型。

五、多态的注意事项

1. 方法覆盖与方法重载的区别

  • 方法覆盖（Overriding）：子类覆盖父类的方法，方法签名必须一致，运行时根据对象的实际类型调用方法。

  • 方法重载（Overloading）：同一个类中，方法名相同但参数列表不同，编译时根据参数列表决定调用哪个方法。

class Parent {
    void show() {
        System.out.println("Parent show()");
    }

    void show(int a) {
        System.out.println("Parent show(int a)");
    }
}

class Child extends Parent {
    @Override
    void show() {
        System.out.println("Child show()");
    }

    void show(int a, int b) {
        System.out.println("Child show(int a, int b)");
    }
}

public class Test {
    public static void main(String[] args) {
        Child obj = new Child();
        obj.show();          // 输出：Child show()
        obj.show(10);        // 输出：Parent show(int a)
        obj.show(10, 20);    // 输出：Child show(int a, int b)
    }
}

 

在上述代码中：

  • show() 是方法覆盖。

  • show(int a) 和 show(int a, int b) 是方法重载。

2. final 方法不能被覆盖

如果父类中的方法被声明为 final，则子类不能覆盖该方法。

class Parent {
    final void show() {
        System.out.println("Parent show()");
    }
}

class Child extends Parent {
    // 下面的代码会导致编译错误，因为父类的方法是 final 的
    // @Override
    // void show() {
    //     System.out.println("Child show()");
    // }
}

 

 

3. 静态方法不能被覆盖

静态方法属于类，而不是对象，因此不能被覆盖。子类可以定义一个同名的静态方法，但这不是覆盖，而是隐藏（Hiding）。

class Parent {
    static void show() {
        System.out.println("Parent show()");
    }
}

class Child extends Parent {
    static void show() {
        System.out.println("Child show()");
    }
}

public class Test {
    public static void main(String[] args) {
        Parent.show(); // 输出：Parent show()
        Child.show();  // 输出：Child show()
    }
}

在上述代码中：

  • Parent.show() 调用的是父类的静态方法。

  • Child.show() 调用的是子类的静态方法。

4. 构造器不能被覆盖

构造器不能被覆盖，但可以通过 super() 调用父类的构造器。

class Parent {
    Parent() {
        System.out.println("Parent constructor");
    }
}

class Child extends Parent {
    Child() {
        super(); // 调用父类的构造器
        System.out.println("Child constructor");
    }
}

public class Test {
    public static void main(String[] args) {
        Child obj = new Child();
        // 输出：
        // Parent constructor
        // Child constructor
    }
}

5. 多态与 instanceof 运算符

instanceof 运算符用于检查对象的实际类型。如果对象是某个类的实例或其子类的实例，则返回 true。

class Parent {
}

class Child extends Parent {
}

public class Test {
    public static void main(String[] args) {
        Parent obj1 = new Parent();
        Parent obj2 = new Child();

        System.out.println(obj1 instanceof Parent); // 输出：true
        System.out.println(obj1 instanceof Child);  // 输出：false
        System.out.println(obj2 instanceof Parent); // 输出：true
        System.out.println(obj2 instanceof Child);  // 输出：true
    }
}

在上述代码中：

  • obj1 是 Parent 类型的对象，因此 obj1 instanceof Parent 返回 true。

  • obj2 是 Child 类型的对象，因此 obj2 instanceof Parent 和 obj2 instanceof Child 都返回 true。

六、多态的实际应用案例

1. 图形绘制系统

假设我们有一个图形绘制系统，需要处理不同类型的图形（如圆形、矩形、三角形等）。通过多态，可以统一处理这些图形。

interface Shape {
    void draw();
}

class Circle implements Shape {
    @Override
    public void draw() {
        System.out.println("Drawing a circle");
    }
}

class Rectangle implements Shape {
    @Override
    public void draw() {
        System.out.println("Drawing a rectangle");
    }
}

class Triangle implements Shape {
    @Override
    public void draw() {
        System.out.println("Drawing a triangle");
    }
}

public class Test {
    public static void main(String[] args) {
        Shape[] shapes = {new Circle(), new Rectangle(), new Triangle()};

        for (Shape shape : shapes) {
            shape.draw();
        }
    }
}

 

在上述代码中：

  • shapes 数组存储了不同类型的图形对象。

  • 通过接口引用 Shape，可以统一调用 draw 方法，而无需关心具体的图形类型。

2. 动物管理系统

假设我们有一个动物管理系统，需要处理不同类型的动物（如狗、猫、鸟等）。通过多态，可以统一处理这些动物。

interface Animal {
    void speak();
}

class Dog implements Animal {
    @Override
    public void speak() {
        System.out.println("Dog barks");
    }
}

class Cat implements Animal {
    @Override
    public void speak() {
        System.out.println("Cat meows");
    }
}

class Bird implements Animal {
    @Override
    public void speak() {
        System.out.println("Bird chirps");
    }
}

public class Test {
    public static void main(String[] args) {
        Animal[] animals = {new Dog(), new Cat(), new Bird()};

        for (Animal animal : animals) {
            animal.speak();
        }
    }
}

在上述代码中：

  • animals 数组存储了不同类型的动物对象。

  • 通过接口引用 Animal，可以统一调用 speak 方法，而无需关心具体的动物类型。

七、总结

多态是面向对象编程中的一个核心概念，它允许通过父类引用或接口操作不同类型的子类对象。多态的主要优势包括提高代码的可维护性、可扩展性和复用性。通过方法覆盖和动态绑定，Java运行时系统可以在运行时根据对象的实际类型调用相应的方法。在实际开发中，多态被广泛应用于各种场景，如图形绘制系统、动物管理系统等。掌握多态的原理和应用，对于编写高质量的面向对象代码至关重要。

java面对对象-多态
weixin_30462049的博客
09-27 619
什么是多态 1.面向对象的三大特性：封装、继承、多态。从一定角度来看，封装和继承几乎都是为多态而准备的。这是我们最后一个概念，也是最重要的知识点。 2.多态的定义：指允许不同类的对象对同一消息做出响应。即同一消息可以根据发送对象的不同而采用多种不同的行为方式。（发送消息就是函数调用） 3.实现多态的技术称为：动态绑定（dynamic binding），是指在执行期间判断所引用对...
深入理解Java三大特性中的多态
08-31
在多态中，方法的调用取决于实际的对象类型，而不是引用类型，这就是所谓的动态绑定。这意味着，即使在编译时不知道引用的具体类型，程序依然可以正确运行，因为实际调用的方法会在运行时根据实际对象确定。 此外，...
java多态理解
12-17
java 个人对于多态理解和一些笔记。
Java多态性理解
Smile&搁浅
11-05 4513
什么是多态 面向对象的三大特性：封装、继承、多态。从一定角度来看，封装和继承几乎都是为多态而准备的。这是我们最后一个概念，也是最重要的知识点。多态的定义：指允许不同类的对象对同一消息做出响应。即同一消息可以根据发送对象的不同而采用多种不同的行为方式。（发送消息就是函数调用）实现多态的技术称为：动态绑定（dynamic binding），是指在执行期间判断所引用对象的实际类型，根据其实际的
第十一讲 | 多态
最新发布
2401_87255690的博客
06-01 1379
多态
Java多态理解
m0_58505748的博客
12-17 518
1.多态的定义 所谓多态就是指程序中定义的引用变量所指向的具体类型和通过该引用变量发出的方法调用在编程时并不确定，而是在程序运行期间才确定，即一个引用变量倒底会指向哪个类的实例对象，该引用变量发出的方法调用到底是哪个类中实现的方法，必须在由程序运行期间才能决定。因为在程序运行时才确定具体的类，这样，不用修改源程序代码，就可以让引用变量绑定到各种不同的类实现上，从而导致该引用调用的具体方法随之改变，即不修改程序代码就可以改变程序运行时所绑定的具体代码，让程序可以选择多个运行状态，这就是多态性。 总的来说：
对Java多态的理解
hellokikiqiqi的博客
11-26 418
多态的定义：指为不同的数据类型的实体提供统一的接口 多态意味着父类型的变量可以引用子类型的对象 多态的分类： 多态可分为变量多态与函数多态。变量多态是指：基类型的变量，可以被赋值基类型对象，也可以被赋值派生类型的对象。函数多态是指，相同的方法调用形式，传送给一个对象变量，可以有不同的行为。因此，变量多态是函数多态的基础。 多态的三种表现形式： 继承 重写 基类引用指向派生类对象 例如：每条狗狗都是一只动物，但并非每只动物对象都是狗狗。因此，总可以将子类的实例传给需要基类的参数，为不同的派生类提
深入理解Java多态.pptx.pptx
12-20
Java多态是面向对象编程的核心特性之一，它允许我们使用一个通用的接口来处理不同类型的对象，从而实现代码的灵活性和可扩展性。在Java中，多态主要通过三种方式实现：继承、接口和方法的重写。 1. **继承与多态**...
Java 继承与多态的深入理解
08-29
"Java 继承与多态的深入理解" 继承是Java语言中的一种机制，允许一个类继承另一个类的特征和行为，使得子类具有父类的各种属性和方法。继承的特点是：在继承关系中，父类更通用、子类更具体。父类和子类需要满足is-...
深入理解Java多态
12-27
深入理解 Java 多态性 在 Java 编程语言中，多态性是指一个对象可以有多种形式的能力，具体来说就是一个对象可以有多个不同的类形态。多态性是面向对象程序设计代码重用的一个最强大机制，Java 多态性的概念也可以...
深入Java核心Java中多态的实现机制.pdf
10-27
以下是深入探讨Java中多态实现机制的详细说明： 1. **子类型多态**： - 子类型多态是Java中最常见的多态形式，它基于继承和方法的覆盖。当一个派生类对象通过基类引用调用方法时，实际执行的是派生类中重写的方法...
什么是多态？
qq_46053026的博客
10-24 258
概念：同样的引用调用同样的方法却做了不同的事 代码：
java中多态的理解
weixin_43142505的博客
01-15 222
java中多态的理解 在处理类型的层次结构时,经常想把一个对象不当作它所属的特定类型来对待,而是当做其基类的对象来对待,这就使得程序员不得不编写依赖于特定对象的代码, 几何形例子: 方法操作的都是泛化的形状,不用去在意这个几何形式圆形,方形等,所有的几何形都可以被移动,擦除,绘制,所以这些方法都是直接对几何形对象放消息,而不需要知道这个几何形对象到底是怎么处理消息, 这样的好处当你添加了一个新的几...
Java的多态理解
weixin_45346856的博客
11-23 212
一、什么是多态？ 多态是同一个行为具有不同表现形式或形态的能力，即对象多种表现形式的体现，就是指程序中定义的引用变量所指向的具体类型和通过该引用变量发出的方法调用在编程时并不确定，而是在程序运行期间才确定，即一个引用变量倒底会指向哪个类的实例对象，该引用变量发出的方法调用到底是哪个类中实现的方法，必须在由程序运行期间才能决定。 二、多态的相关知识 使用多态必须满足三个必要条件：继承、重写、父类引用指向子类。 使用多态的前提条件是必须有子父类关系。 多态体现为父类变量可以引用子类对象。 定义格式：父类类型 变
深入理解重写、隐藏、和静、动态绑定的本质
从左到右
11-12 693
深入理解重写、隐藏、和静、动态绑定的本质 文章目录问题引入重写隐藏动态绑定通俗理解静态绑定总结总结 问题引入 大家都知道成员方法能被继承和重写，那么静态变量或者静态方法能否被子类继承？能否被重写？ 于是写了一段代码先验证下： //定义父类 public class SuperClass { static int SuperVar = 10; public static void method(){ System.out.println("this SuperClass");
Java多态的理解
weixin_60110002的博客
12-08 1902
Java 多态 除封装和继承之外，面向对象程序设计的第三个支柱。简单来说，多态意味着父类型的变量可以引用子类型的对象 ???? 多态：同一个行为具有不同表现形式或形态的能力，即对象多种表现形式的体现，例如子类的实例也可作为父类的实例（Student类是Person类的子类，则一个Student的对象便既是Student，也是Person） 定义与使用格式 定义格式：父类类型 变量名=new 子类类型(); 例如，通过Object p = new Person();代码定义一个变量p
关于java多态的理解
weiyunna的博客
10-19 256
1、多态的定义与使用格式 定义格式：父类类型 变量名=new 子类类型(); 2、什么是多态： 当运行时调用引用变量的方法时，其方法行为总是表现出子类方法的行为特征，而不是父类方法的行为特征，这就表现出： 相同类型的变量调用同一个方法时表现出不同的行为特征，这就是多态。 3、多态的前提条件： 存在父子间的继承关系（extends） 子类中存在方法重写（override） 父类的引用类型指向子类对象（见1，对于父类中定义的方法，如果子类中重写了该方法，那么父类类型的引...
通过购物车案例深入理解Java异常多态
这表明，文件内容将为Java框架初学者和现学者提供一个具体的实践案例，帮助他们理解多态和异常处理在实际项目中的应用。 根据标题和描述，我们可以得知以下知识点： 1. 多态的概念：多态是面向对象编程的核心特性...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值