【面试】解释一下C++和Java在面向对象编程中的多态性区别

面试模拟场景

面试官: 你能解释一下C++和Java在面向对象编程中的多态性区别吗？

参考回答示例

1. 多态性

多态性（Polymorphism）：

• 多态性指的是同一操作在不同对象上可以有不同的表现形式。在运行时，能够根据对象的实际类型调用相应的方法，而不需要了解对象的具体类型。

2. C++中的多态性

1.1 实现方式：

• 静态多态性：

  • C++的静态多态性通过函数重载和运算符重载实现。在编译时决定调用哪个函数。静态多态性在编译期完成，编译器根据参数类型确定函数的调用。
  • 例如：

    void print(int i) {
        std::cout << "Integer: " << i << std::endl;
    }
    
    void print(double d) {
        std::cout << "Double: " << d << std::endl;
    }
    

• 动态多态性：

  • C++的动态多态性通过虚函数（virtual function）实现。虚函数允许在运行时决定调用哪个函数，这是通过虚函数表（vtable）和指针实现的。
  • 基类中的函数声明为virtual，派生类可以覆盖该函数。在运行时，根据对象的实际类型调用对应的函数。
  • 例如：

    class Base {
    public:
        virtual void show() {
            std::cout << "Base class" << std::endl;
        }
    };
    
    class Derived : public Base {
    public:
        void show() override {
            std::cout << "Derived class" << std::endl;
        }
    };
    
    Base* obj = new Derived();
    obj->show();  // 输出 "Derived class"
    

1.2 使用方式：

• 在C++中，使用指向基类的指针或引用来实现多态性。这要求基类的析构函数也需要定义为virtual，以防止内存泄漏。

• 抽象类与纯虚函数：

  • C++支持纯虚函数（pure virtual function），用于定义抽象类。纯虚函数没有实现，必须在派生类中实现。
  • 例如：

    class AbstractBase {
    public:
        virtual void show() = 0;  // 纯虚函数
    };
    

1.3 底层实现：

虚函数表（Vtable）：

• 虚函数表是一个由编译器生成的内部数据结构，用于存储类的虚函数指针。每个含有虚函数的类都有一张虚函数表，表中记录了该类的虚函数地址。
• 结构：
  • 虚函数表是一个指针数组，每个元素是一个指向函数的指针。这些指针对应类的虚函数，在运行时用于动态绑定。

虚表指针（Vptr）：

• 虚表指针是对象的一部分，它指向对象所属类的虚函数表。虚表指针通常在对象创建时由编译器自动插入到对象的内存布局中，并初始化为指向相应的虚函数表。
• 作用：
  • 虚表指针确保了即使通过基类指针调用函数，程序也能够在运行时正确地找到并调用派生类的函数。

1. 编译时：

• 在编译阶段，编译器为每个含有虚函数的类生成一个虚函数表。表中存储的是该类所有虚函数的指针。如果某个虚函数在派生类中被覆盖（override），则在派生类的虚函数表中，指向基类函数的指针会被替换为指向派生类覆盖函数的指针。

2. 对象实例化时：

• 当一个类的对象被实例化时，如果该类包含虚函数，编译器会自动在对象中添加一个隐藏的虚表指针（vptr）。这个虚表指针指向该对象所属类的虚函数表。
• 对象创建后，虚表指针被初始化为指向相应类的虚函数表。例如，基类对象的虚表指针指向基类的虚函数表，而派生类对象的虚表指针指向派生类的虚函数表。

3. 运行时（调用时）：

• 当通过基类指针或引用调用虚函数时，程序会通过虚表指针找到虚函数表，然后在虚函数表中查找相应的虚函数指针，最后通过该指针调用实际的函数实现。
• 动态绑定： 由于虚表指针在运行时指向了派生类的虚函数表，基类指针可以调用到派生类的实现。这就是C++中动态多态性的实现方式。

3. Java中的多态性

2.1 实现方式：

• 静态多态性：

  • Java的静态多态性通过方法重载（method overloading）实现。与C++类似，重载方法在编译时确定调用关系。

• 动态多态性：

  • Java的动态多态性通过方法重写（method overriding）实现。派生类覆盖基类中的方法，在运行时通过JVM的动态绑定来决定调用哪个方法。
  • 例如：

    class Base {
        void show() {
            System.out.println("Base class");
        }
    }
    
    class Derived extends Base {
        @Override
        void show() {
            System.out.println("Derived class");
        }
    }
    
    Base obj = new Derived();
    obj.show();  // 输出 "Derived class"
    

2.2 使用方式：

• 抽象类与接口：
  • Java中，可以使用抽象类（abstract class）和接口（interface）来实现多态性。抽象类可以包含抽象方法和具体方法，而接口则只包含抽象方法（Java 8之后接口可以有默认方法和静态方法）。
  • 例如：

    abstract class Animal {
        abstract void sound();
    }
    
    class Dog extends Animal {
        void sound() {
            System.out.println("Woof");
        }
    }
    
    Animal obj = new Dog();
    obj.sound();  // 输出 "Woof"
    

2.3 底层实现：

• 方法表（method table）：
  • Java的动态多态性通过JVM的动态绑定机制实现。在Java中，对象的实际类型在运行时确定，并使用方法表（类似于C++的vtable）来决定调用哪一个方法。

4. 主要区别

1. 多态性实现的语法：

• C++： 使用虚函数（virtual function）和指针或引用来实现动态多态性。需要显式声明virtual关键字。
• Java： 使用方法重写（method overriding）来实现动态多态性，默认所有非静态方法都可以被重写，不需要显式声明。

2. 内存管理：

• C++： 需要手动管理内存，并且基类析构函数必须定义为virtual，以确保派生类的对象在销毁时正确调用析构函数。
• Java： 有自动垃圾回收机制（Garbage Collection），不需要手动管理内存。

3. 继承的方式：

• C++： 支持多继承，但这可能导致复杂的依赖关系（如菱形继承问题），C++通过虚继承解决多继承中的二义性问题。
• Java： 不支持多继承，但支持多接口的实现，使用接口来规避多继承的复杂性。

4. 虚函数表的实现：

• C++： 每个类有一个虚函数表，动态多态性依赖于该表的查找。
• Java： 使用方法表来实现动态绑定，JVM负责方法的查找和调用。

5. 总结

• C++与Java的多态性都允许在运行时基于对象的实际类型调用方法，但它们的实现方式和使用方式有所不同。
  • C++： 依赖于虚函数表，使用virtual关键字来实现动态多态性，并且需要手动管理内存。
  • Java： 动态多态性通过方法重写实现，所有非静态方法都支持重写，由JVM管理内存并执行方法查找。