一、多态的基本概念
1. 定义
· 多态（Polymorphism）指同一操作作用于不同类的对象时，可以有不同的解释和执行结果
· "多种形态"：同一接口，不同实现
2. 分类
· 编译时多态（静态多态）
· 方法重载（Overloading）
· 运算符重载
· 运行时多态（动态多态）
· 方法重写/覆盖（Overriding）
· 基于继承和接口实现
二、静态多态（编译时多态）
1. 方法重载（Overloading）
```java
class Calculator {
// 方法名相同，参数列表不同
public int add(int a, int b) {
return a + b;
}
public double add(double a, double b) {
return a + b;
}
public int add(int a, int b, int c) {
return a + b + c;
}
}
```
2. 运算符重载（部分语言支持）
```cpp
class Vector {
public:
Vector operator+(const Vector& other) {
// 重载+运算符
}
};
```
三、动态多态（运行时多态）
1. 方法重写/覆盖（Overriding）
```java
class Animal {
public void makeSound() {
System.out.println("动物发出声音");
}
}
class Dog extends Animal {
@Override
public void makeSound() {
System.out.println("汪汪汪");
}
}
class Cat extends Animal {
@Override
public void makeSound() {
System.out.println("喵喵喵");
}
}
```
2. 实现条件
· 继承关系
· 方法重写
· 父类引用指向子类对象（向上转型）
```java
Animal myAnimal = new Dog(); // 向上转型
myAnimal.makeSound(); // 输出"汪汪汪"
```
四、多态的实现机制
1. 虚函数（C++）
```cpp
class Base {
public:
virtual void show() { // 虚函数
cout << "Base show" << endl;
}
};
class Derived : public Base {
public:
void show() override {
cout << "Derived show" << endl;
}
};
```
2. 虚函数表（vtable）
· C++通过虚函数表实现动态绑定
· 每个有虚函数的类都有一个虚函数表
· 对象包含指向vtable的指针
3. Java/C#的实现
· Java中所有非private、非static、非final方法都是虚方法
· 通过方法表实现
· final关键字可以禁止方法被重写
五、接口与抽象类的多态
1. 接口多态
```java
interface Shape {
double area();
}
class Circle implements Shape {
public double area() {
return Math.PI * radius * radius;
}
}
class Rectangle implements Shape {
public double area() {
return width * height;
}
}
// 使用
Shape shape1 = new Circle();
Shape shape2 = new Rectangle();
```
2. 抽象类多态
```java
abstract class Employee {
abstract double calculateSalary();
}
class Manager extends Employee {
double calculateSalary() {
return baseSalary + bonus;
}
}
```
六、多态的应用场景
1. 设计模式中的应用
· 工厂模式
· 策略模式
· 模板方法模式
· 命令模式
2. 实际应用
```java
// 支付系统多态示例
interface Payment {
void pay(double amount);
}
class CreditCardPayment implements Payment {
public void pay(double amount) {
// 信用卡支付逻辑
}
}
class PayPalPayment implements Payment {
public void pay(double amount) {
// PayPal支付逻辑
}
}
class PaymentProcessor {
public void processPayment(Payment payment, double amount) {
payment.pay(amount); // 多态调用
}
}
```
七、多态的优势
1. 提高代码可扩展性
· 新增子类不影响现有代码
2. 提高代码复用性
· 父类定义通用接口
3. 提高代码灵活性
· 运行时决定调用哪个方法
4. 实现接口统一
· 不同对象通过统一接口访问
八、相关概念对比
特性 重载 (Overload) 重写 (Override)
发生位置 同一类中 父子类之间
参数列表 必须不同 必须相同
返回类型 可以不同 相同或协变
访问权限 无限制 不能更严格
发生阶段 编译时 运行时
九、注意事项
1. 构造器不能多态
· 构造器是隐式static的，不具备多态性
2. 静态方法不能多态
```java
class Parent {
static void show() {
System.out.println("Parent");
}
}
class Child extends Parent {
static void show() { // 隐藏，不是重写
System.out.println("Child");
}
}
Parent p = new Child();
p.show(); // 输出"Parent"，静态方法调用取决于引用类型
```
3. 字段不能多态
```java
class Parent {
String name = "Parent";
}
class Child extends Parent {
String name = "Child"; // 隐藏父类字段
}
Parent p = new Child();
System.out.println(p.name); // 输出"Parent"
```
十、面试常见问题
1. 多态的实现原理是什么？
· C++：虚函数表
· Java：方法表
2. 重载和重写的区别？
· 编译时 vs 运行时
· 同一类 vs 继承关系
· 参数列表不同 vs 相同
3. 如何防止方法被重写？
· C++：使用final关键字（C++11）
· Java：使用final修饰方法
· C#：使用sealed关键字
4. 多态的性能影响？
· 轻微的性能开销（虚函数调用）
· 现代优化技术（如内联缓存）减少了开销
总结
多态是面向对象编程的核心特性，它通过：
· 静态多态提高代码的灵活性
· 动态多态提高系统的扩展性和可维护性
理解多态的关键在于掌握：
1. 向上转型
2. 动态绑定机制
3. 接口和抽象类的使用
4. 多态在设计模式中的应用
多态使得程序更加模块化，降低了模块间的耦合度，是构建大型、可维护软件系统的重要基础。
