Java 多态详解：概念、方法重写与动态绑定实战

什么是 Java 多态？

多态 是 Java 面向对象编程（OOP）的核心概念。当类通过继承关联时产生，允许单一接口代表不同底层形式。结果是方法调用可根据运行时实际对象类型调用不同实现。

就像智能手机可通过语音、短信、图片、邮件通信。目标——通信——相同，但每种模式行为不同。这就是生活中的多态。

你将学到

• Java 多态定义
• 实战 OOP 示例
• 方法重写
• 重载 vs 重写
• 动态（运行时）多态
• 静态 vs 动态多态
• super 关键字

OOP 中的 Java 多态示例

考虑基类 Account 提供 deposit() 和 withdraw()。两个子类 SavingsAccount 和 CheckingAccount 继承这些方法，因为操作相同。

适应需求变更

当需要透支等新功能时，PrivilegedAccount 子类可重写 withdraw() 提供新逻辑，无需碰现有子类。这演示了多态的可维护性优势。

Java 方法重写

重写发生在子类为父类已定义的方法提供自己的实现。方法签名（名称、参数、返回类型）必须完全匹配。

关键规则

• 重写方法可见性可变宽（如 protected 到 public），不可变窄。
• 返回类型必须相同或协变。

示例：

class Doctor {
    public void treatPatient() {
        // 通用治疗逻辑
    }
}
class Surgeon extends Doctor {
    @Override
    public void treatPatient() {
        // 专科手术治疗
    }
}
public class Run {
    public static void main(String[] args) {
        Doctor doctor = new Doctor();
        doctor.treatPatient(); // 执行 Doctor.treatPatient()
        Surgeon surgeon = new Surgeon();
        surgeon.treatPatient(); // 执行 Surgeon.treatPatient()
    }
}

重载 vs 重写

void sum(int a, int b);
void sum(int a, int b, int c);
void sum(float a, double b);

class X { int sum() { ... } }
class Y extends X {
    @Override int sum() { ... }
}

动态多态（运行时）

当父类引用指向子类对象时，JVM 在运行时解析方法调用。这是真正的多态。

Doctor doc = new Surgeon();
doc.treatPatient(); // 执行 Surgeon.treatPatient()

实际调用的方法取决于对象的运行时类型，而非引用类型。

静态 vs 动态多态

静态多态（重载）在编译期解析，动态多态（重写）在运行期解析。

void sum(int a, int b);
void sum(float a, double b);

Doctor d = new Surgeon();
d.treatPatient();

使用 super 关键字

子类需扩展父类方法时，super 先调用父类实现再添加自身逻辑。

class Surgeon extends Doctor {
    @Override
    public void treatPatient() {
        super.treatPatient(); // 基础逻辑
        // 外科医生特有逻辑
    }
}

同样，super 可访问父类的 protected 或 public 字段。

实战示例：继承、多态与 Super

将下面代码复制到 IDE 观察输出。

public class Test {
    public static void main(String[] args) {
        X x = new X();
        Y y = new Y();
        y.m2();
        // 取消注释查看继承效果
        // x.m1();
        // y.m1();
        // x = y; // 父引用指向子对象
        // x.m1();
        // y.a = 10; // 错误：a 是 private
    }
}
class X {
    private int a;
    int b;
    public void m1() {
        System.out.println("This is method m1 of class X");
    }
}
class Y extends X {
    int c;
    @Override
    public void m1() {
        System.out.println("This is method m1 of class Y");
    }
    public void m2() {
        super.m1();
        System.out.println("This is method m2 of class Y");
    }
}

核心要点

• 多态让对象通过继承呈现多种形态。
• 方法重写在保持相同签名下改变子类行为。
• 动态多态在运行时解析方法调用，实现灵活代码。
• 静态多态（重载）是编译期，动态多态是运行期。
• super 关键字让子类调用父方法或访问 protected 成员。