java 通过方法重写实现运行时绑定,核心做法是让父类引用指向子类对象并调用被重写的方法,jvm 会根据实际对象的类型动态决定执行哪个版本。具体操作是定义包含同名同参方法的父子类,在子类中使用 @override 注解标记重写,并在主程序中创建子类实例赋给父类变量进行调用。这样在编译期检查方法签名合法性,而在运行期根据对象真实类型执行对应逻辑。

如何定义支持重写的父子类结构
要实现多态,必须建立继承关系并确保方法签名一致。首先定义一个父类 Animal,其中包含一个普通方法 makeSound()。接着定义子类 Dog 继承自 Animal,并在子类中提供 makeSound() 的具体实现。关键在于子类方法不能缩小父类方法的访问权限,且参数列表必须完全相同。这种结构为后续的动态绑定提供了基础,使得编译器能够识别出这是一个合法的重写行为。

public class Animal {
public void makeSound() {
System.out.println("Some sound");
}
}
public class Dog extends Animal {
@Override
public void makeSound() {
System.out.println("Woof");
}
}
public class Main {
public static void main(String[] args) {
Animal myDog = new Dog();
myDog.makeSound();
}
}
上述代码定义了基础的继承体系。在 Main 类中,我们创建了 Dog 的实例,但将其赋值给了 Animal 类型的引用变量 myDog。当调用 myDog.makeSound() 时,虽然引用类型是 Animal,但实际对象是 Dog。这段代码展示了最基础的多态形态,即父类引用指向子类对象。
立即学习“Java免费学习笔记(深入)”;
为什么编译期与运行期的行为不同
理解运行时绑定的关键在于区分编译期和运行期的决策过程。在编译阶段,编译器只关心引用变量的类型,即 Animal。它检查 Animal 类中是否存在 makeSound() 方法,如果存在则编译通过,此时编译器认为调用的是父类的方法。然而,在程序运行期间,JVM 会检查引用变量所指向的实际堆内存对象类型。由于实际对象是 Dog 实例,JVM 会查找 Dog 类中是否有该方法的重写版本。如果有,JVM 就会执行 Dog 中的实现,这就是所谓的动态分派或运行时绑定。这种机制允许我们在不修改原有调用代码的情况下,通过替换不同的子类对象来获得不同的行为结果。

// 对比测试:使用父类引用调用不同子类
public class Cat extends Animal {
@Override
public void makeSound() {
System.out.println("Meow");
}
}
public class TestPolymorphism {
public static void main(String[] args) {
Animal a1 = new Dog();
Animal a2 = new Cat();
a1.makeSound(); // 输出 Woof
a2.makeSound(); // 输出 Meow
}
}
通过引入 Cat 类并重写 makeSound(),我们可以进一步验证这一机制。在 TestPolymorphism 中,我们分别用 Dog 和 Cat 的实例初始化了 Animal 类型的引用。尽管调用方式完全相同,都是 a.makeSound(),但由于底层实际对象的不同,最终输出的结果也截然不同。这证明了方法调用的目标是在运行时确定的,而非编译时固定。
静态方法是否参与运行时绑定
并非所有方法都支持运行时绑定。静态方法(static)和私有方法(private)不参与多态的动态分派过程。静态方法属于类本身,而不是类的实例。如果在子类中定义了一个与父类静态方法签名相同的静态方法,这被称为方法隐藏(Method Hiding),而不是重写。在这种情况下,调用哪个版本的静态方法完全取决于引用变量的编译时类型,而不是运行时的实际对象类型。例如,如果 Animal 有一个静态方法 info(),而 Dog 也定义了一个同名的静态方法,那么当使用 Animal 引用调用 info() 时,即使该引用指向 Dog 实例,执行的仍然是 Animal 中的静态方法。这是因为静态方法的绑定发生在编译期,遵循静态分派规则。


















