java 中多态方法调用看左边,即编译时声明的引用类型决定调用哪个方法。具体做法是:定义父类引用指向子类对象,编译器根据引用类型检查方法是否存在并确定签名,运行时 jvm 根据实际对象类型执行对应的方法实现。若方法为静态或私有,则完全由左边决定;若为实例方法且被子类重写,则动态绑定到右边对象的实际类型。

编译期如何确定方法签名
编译期只看左边的引用类型,检查该方法是否在父类中声明。如果父类没有该方法,编译直接报错,即使子类有同名方法也不行。这确保了类型安全,防止调用不存在的 API。

public class Animal {
public void speak() {
System.out.println("Animal speaks");
}
}
public class Dog extends Animal {
@Override
public void speak() {
System.out.println("Dog barks");
}
public void fetch() {
System.out.println("Dog fetches");
}
}
public class Main {
public static void main(String[] args) {
Animal myPet = new Dog(); // 左边是 Animal,右边是 Dog
myPet.speak(); // 编译通过,运行输出 "Dog barks"
// myPet.fetch(); // 编译错误:Animal 类中没有 fetch 方法
}
}预期结果:`myPet.speak()` 输出 "Dog barks"。`myPet.fetch()` 导致编译失败,因为 `Animal` 引用无法访问 `Dog` 特有的方法。
立即学习“Java免费学习笔记(深入)”;
在代码库出现结构漂移之前,扫描JS或TS代码库中的禁止导入、循环依赖、孤立模块和其他依赖规则违规情况。
运行期如何确定具体实现
运行期 JVM 根据右边的实际对象类型,查找并重写(Override)了的方法。这是动态绑定的核心,允许同一个接口在不同对象上表现出不同行为。只有非静态、非私有、非 final 的实例方法才参与这种动态分发。

public class Cat extends Animal {
@Override
public void speak() {
System.out.println("Cat meows");
}
}
public class Main {
public static void main(String[] args) {
Animal pet1 = new Dog();
Animal pet2 = new Cat();
pet1.speak(); // 输出 "Dog barks"
pet2.speak(); // 输出 "Cat meows"
}
}预期结果:`pet1.speak()` 输出 "Dog barks",`pet2.speak()` 输出 "Cat meows"。尽管两个引用类型都是 `Animal`,但实际执行的是各自子类重写的版本。
当子类未重写父类方法时会发生什么
如果子类没有重写父类中的某个实例方法,JVM 会向上查找父类的实现并执行。此时虽然还是动态绑定机制,但找到的代码块位于父类中。这常用于提供默认行为,子类可选择性覆盖。
public class Bird extends Animal {
// 未重写 speak 方法
public void fly() {
System.out.println("Bird flies");
}
}
public class Main {
public static void main(String[] args) {
Animal bird = new Bird();
bird.speak(); // 输出 "Animal speaks"
// bird.fly(); // 编译错误:Animal 类型无 fly 方法
}
}预期结果:`bird.speak()` 输出 "Animal speaks",因为 `Bird` 类没有提供自己的 `speak` 实现,所以沿继承链找到 `Animal` 的实现并执行。

















