java和c++两种语言的多态对比（java选手转c++必学！）多态-保研机试，大厂面试必问

多态（Polymorphism）是面向对象编程（OOP）中的一个重要概念，指的是同一个接口或基类在不同情况下可以表现出不同的行为。多态允许对象通过相同的接口或方法名以不同的方式执行操作，这种能力使代码更加灵活和可扩展。

java多态的主要形式

1.编译时多态（静态多态）：

• 方法重载（Method Overloading）：在同一个类中，可以定义多个同名方法，但它们的参数类型、数量或顺序不同。编译器在编译时根据方法调用时传递的参数决定调用哪个方法。
• 运算符重载（Operator Overloading）：在某些编程语言中（如C++），允许开发者为类定义特定的操作符行为，使其适用于类的对象。
  示例（Java中的方法重载）：

class Calculator {
    int add(int a, int b) {
        return a + b;
    }

    double add(double a, double b) {
        return a + b;
    }
}

上述代码中，同名方法 add 有两个不同的版本，编译器会根据参数类型选择调用哪个方法。

2.运行时多态（动态多态）：

• 方法重写（Method Overriding）：子类可以重写（覆盖）父类的方法，使得子类对象在调用该方法时表现出不同的行为。运行时多态依赖于继承和接口，具体的方法调用在运行时决定。
  示例（Java中的方法重写）：

class Animal {
    void sound() {
        System.out.println("Animal makes a sound");
    }
}

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

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

使用多态：

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

        myDog.sound(); // 输出: Dog barks
        myCat.sound(); // 输出: Cat meows
    }
}

在上述代码中，myDog 和 myCat 都是 Animal 类型的引用，但它们在运行时调用的 sound 方法根据实际对象类型（Dog 或 Cat）表现出不同的行为。

多态的优点
代码复用：通过使用多态，可以编写更加通用和可重用的代码。
灵活性：程序可以在不修改现有代码的情况下扩展新的功能或行为。
可维护性：由于多态允许通过接口或基类来操作不同的对象，因此可以更轻松地修改和扩展代码。

c++多态的主要形式

在C++中，多态分为两种主要形式：

1.编译时多态（静态多态）：

• 函数重载（Function Overloading）：类似于前面提到的Java中的方法重载，C++允许在同一个作用域中定义多个同名函数，但这些函数的参数列表必须不同。
• 运算符重载（Operator Overloading）：C++允许开发者为自定义类定义运算符，使得这些运算符可以用于类对象。
  示例（函数重载和运算符重载）：
  ps 这个部分几乎和java相同！

class Example {
public:
    int add(int a, int b) {
        return a + b;
    }

    double add(double a, double b) {
        return a + b;
    }

    Example operator+(const Example& other) {
        Example result;
        // 假设有某种数据成员需要相加
        return result;
    }
};

2.运行时多态（动态多态）：
虚函数（Virtual Function）：C++中实现运行时多态的核心机制。通过在基类中定义虚函数，派生类可以重写这些虚函数，从而在运行时根据对象的实际类型调用相应的方法。

• 注意点：
• 父类中可继承函数必须用virtual来定义虚函数，派生类（子类）才能重写该函数
• 声明派生类的时候必须用父类的指针！

Animal* myOtherAnimal = new Cat();

• 表示继承的语句

class Dog : public Animal{
public：……}

代码示例（虚函数实现多态）：

#include <iostream>
using namespace std;

class Animal {
public:
    virtual void sound() {
        cout << "Animal makes a sound" << endl;
    }
};

class Dog : public Animal {
public:
    void sound() override {
        cout << "Dog barks" << endl;
    }
};
//继承的基本语法！表示Animal类是cat的父类
class Cat : public Animal {
public:
    void sound() override {
        cout << "Cat meows" << endl;
    }
};

int main() {
//注意 这个地方必须是指针！
    Animal* myAnimal = new Dog();
    Animal* myOtherAnimal = new Cat();

    myAnimal->sound();         // 输出: Dog barks
    myOtherAnimal->sound();    // 输出: Cat meows

    delete myAnimal;
    delete myOtherAnimal;

    return 0;
}

在这个例子中，Animal类中的sound函数被声明为virtual，因此在Dog和Cat类中重写这个函数时，C++在运行时根据对象的实际类型调用适当的sound函数。

• 多态的优点
  灵活性：允许使用基类指针或引用来操作派生类对象，代码更具扩展性。
  可扩展性：在不改变基类代码的情况下，可以扩展新的派生类，并使其融入现有的框架中。
  代码复用：通过继承和多态，可以重用代码并减少冗余。

总结

java和c++中多态的概念基本一致，都是分为编译时多态（同一接口，不同操作）和运行时多态（子类或派生类重写父类的方法），优点也是一致的，但是实现方法有区别