2023年9月20日，周三上午

今天写作业的时候遇到了多态，但我感觉自己多多态还是不够理解，于是又深入研究了一下。

不过，我觉得我写的这篇文章还不够完整，比如说没提到什么时候适合使用多态，以后有空再写上吧。

目录

• 什么是多态
• Java
• 方法重写（Method Overriding）
• 接口（Interface）
• 抽象类（Abstract Class）
• 泛型（Generics）
• C++
• 虚函数（Virtual Functions）
• 函数指针（Function Pointers）

什么是多态

多态允许不同类的对象对相同的消息（方法）作出不同的响应。

通俗来说就是，对于同一个函数makeSound，Animal类的对象的响应是输出"发出声音"，Cat类的对象的响应是输出“喵喵...”，Dog类的对象的响应是输出“汪汪...”

多态性使得程序能够以一种通用的方式处理不同类型的数据或对象，而无需关心它们的具体类型。

在不同的编程语言中，多态性的实现方式和语法细节可能有所不同，但多态性的核心思想是相同的：允许不同类型的对象在统一的接口下表现出不同的行为。

Java

在Java中，可以使用以下几种方法来实现多态性：

方法重写（Method Overriding）

这是最常见的多态性实现方式。它允许子类重写父类的方法，从而在调用相同方法名的情况下，根据对象的实际类型来执行不同的方法体。要使用方法重写，子类需要覆盖父类中的方法，并使用@Override注解确保正确地重写了方法。

class Animal {
    void makeSound() {
        System.out.println("动物发出声音");
    }
}

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

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

接口（Interface）

Java的接口允许不同的类实现相同的接口，然后通过接口引用对象，从而实现多态性。不同的类可以以不同的方式实现接口中的方法。

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");
    }
}

抽象类（Abstract Class）

抽象类也可以用于实现多态性，类似于接口，子类必须实现抽象类中的抽象方法。

abstract class Animal {
    abstract void makeSound();
}

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

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

泛型（Generics）

泛型允许编写通用的代码，以处理不同类型的数据。通过使用泛型类型参数，可以在编译时确定对象的类型，并执行相应的操作。

C++

在C++中，有两种主要方式可以实现多态性：虚函数和函数指针。

但是，虚函数是实现多态性的主要和推荐方式

虚函数（Virtual Functions）

在C++中，可以将成员函数声明为虚函数，以实现多态性。这通常用于面向对象编程中的继承和多态。虚函数通过在基类中声明并在派生类中重写来实现。这样，派生类可以为虚函数提供自己的实现，而基类的指针或引用可以用于调用这些虚函数，具体的调用会根据实际对象的类型而决定。

class Animal {
public:
    virtual void makeSound() {
        std::cout << "动物发出声音" << std::endl;
    }
};

class Dog : public Animal {
public:
    void makeSound() override {
        std::cout << "汪汪" << std::endl;
    }
};

class Cat : public Animal {
public:
    void makeSound() override {
        std::cout << "喵喵" << std::endl;
    }
};

使用虚函数时，可以使用基类指针或引用来实现多态性，具体执行哪个版本的函数取决于运行时对象的类型。

函数指针（Function Pointers）

在C++中，也可以使用函数指针来实现多态性。函数指针是指向函数的指针，可以动态指定要调用的函数。可以使用函数指针数组或函数指针成员来实现多态性，根据需要调用不同的函数。

class Animal {
public:
    void (*makeSound)() = nullptr;

    void playSound() {
        if (makeSound != nullptr) {
            makeSound();
        }
    }
};

void animalSound() {
    std::cout << "动物发出声音" << std::endl;
}

void dogSound() {
    std::cout << "汪汪" << std::endl;
}

int main() {
    Animal animal;
    animal.makeSound = animalSound;

    Animal dog;
    dog.makeSound = dogSound;

    animal.playSound(); // 调用 Animal 的声音函数
    dog.playSound();    // 调用 Dog 的声音函数

    return 0;
}

这种方法允许在运行时选择要调用的函数，但相对于虚函数，它更为复杂，需要手动管理函数指针。

总结来说，在C++中，虚函数是实现多态性的主要和推荐方式，因为它更容易使用并且具有更好的可读性和维护性。函数指针可以用于实现多态性，但它通常更适用于特定的高级用例，比如函数回调。虚函数是C++中实现多态性的首选方式。