多态是怎么实现的？动态绑定和静态绑定有什么区别？

简化版

多态指「同一个方法调用，根据对象的实际类型执行不同的实现」——父类引用指向子类对象，调 animal.sound() 时，实际执行的是子类重写的方法。它的实现靠 动态绑定（运行时绑定）：编译期只确定「调用哪个方法签名」，具体调哪个实现要到运行时看对象的实际类型才决定。底层机制是虚方法表（vtable）——每个类有一张方法表，记录它每个方法的实际入口地址，子类重写父类方法时表里的地址指向子类实现；调用时通过对象找到它的类的 vtable、按方法在表里的位置找到真正要执行的方法。而静态绑定（编译期绑定） 用于 static、private、final 方法和构造器——它们不能被重写，编译期就能确定调哪个，无需运行时查找。

详细版

多态的三个前提：继承（子类继承父类）、重写（子类重写父类方法）、父类引用指向子类对象。

class Animal { void sound() { System.out.println("..."); } }
class Dog extends Animal { void sound() { System.out.println("汪"); } }
class Cat extends Animal { void sound() { System.out.println("喵"); } }

Animal a = new Dog();   // 父类引用指向子类对象
a.sound();              // 输出"汪"——运行时看实际类型 Dog，调 Dog 的 sound
a = new Cat();
a.sound();              // 输出"喵"——同一行代码，实际类型变了，执行不同实现

动态绑定 vs 静态绑定：

维度	静态绑定（早绑定）	动态绑定（晚绑定）
绑定时机	编译期	运行时
依据	引用的声明类型	对象的实际类型
适用方法	static、private、final、构造器	普通实例方法（可被重写的）
字节码指令	invokestatic/invokespecial	invokevirtual/invokeinterface
能否多态	否	是

虚方法表（vtable）机制：

每个类在方法区有一张虚方法表，记录该类每个方法的实际入口地址：
  Animal 的 vtable：[sound → Animal.sound]
  Dog 的 vtable：  [sound → Dog.sound]    ← 重写了，指向 Dog 自己的实现
  Cat 的 vtable：  [sound → Cat.sound]

调用 a.sound() 时：
  1. 通过对象头找到它的实际类（Dog）
  2. 找到 Dog 的 vtable
  3. 按 sound 方法在表里的固定位置（下标）取出实际入口 → Dog.sound
  → 所以执行的是实际类型的方法（多态）

⚠️ 一个常见坑：成员变量（字段）和静态方法不具有多态性。字段访问是「静态绑定」——看引用的声明类型，不看实际类型；静态方法也是静态绑定（属于类不属于对象）。所以 Animal a = new Dog(); a.name 取的是 Animal 声明的 name、a.staticMethod() 调的是 Animal 的静态方法（虽然不推荐用对象调静态方法）。只有普通实例方法才有多态（动态绑定）。

完整版教学

一、多态是什么：一个调用、多种行为

多态（Polymorphism）是面向对象三大特性（封装、继承、多态）之一，核心是「同一个方法调用，因对象实际类型不同而表现出不同行为」：

多态的价值：面向抽象编程、消除 if-else 分支
  没有多态：
    if (animal instanceof Dog) dogSound();
    else if (animal instanceof Cat) catSound();  // 加一种动物就要改这里
  有多态：
    animal.sound();  // 不管是什么动物，都调它自己的 sound，加动物不用改调用处

多态让你能「面向父类/接口编程，而不关心具体是哪个子类」——写一个 feed(Animal a) { a.sound(); }，传 Dog 传 Cat 都行，各自表现各自的行为。这带来了可扩展性（加新子类不用改已有代码，符合开闭原则）和解耦（调用方不依赖具体实现）。理解「多态 = 一个调用根据实际类型表现不同行为 = 面向抽象编程」，就理解了它为什么是 OOP 的核心，也理解了「为什么它需要『运行时才决定调哪个方法』」——因为调用时你（编译器）还不知道实际是哪个子类。

二、静态绑定与动态绑定的分界

「调用一个方法」要解决「到底执行哪段代码」，这个「确定执行哪段代码」的过程叫绑定，分两种：

静态绑定（编译期绑定/早绑定）：
  编译时就能确定调哪个方法 → 直接生成对该方法的调用
  适用：static、private、final 方法、构造器
  这些方法有个共同点——不能被重写（子类无法覆盖它们）
  → 编译期就知道确切调哪个，无需运行时判断

动态绑定（运行时绑定/晚绑定）：
  编译时只确定"方法签名"，具体调哪个实现要运行时看对象实际类型
  适用：普通的、可被重写的实例方法
  → 因为可能被子类重写，编译期不知道实际对象是哪个子类，只能运行时定

关键分界是「这个方法能不能被重写」：不能被重写的（static/private/final/构造器）用静态绑定（编译期定死，没有多态）；能被重写的普通实例方法用动态绑定（运行时看实际类型，有多态）。为什么 static/private/final 不能被重写？static 属于类不属于对象、private 子类看不见、final 明确禁止重写——它们都「不存在多个版本」，所以编译期就能定。理解「绑定的分界是能否重写」，就理解了为什么只有普通实例方法有多态。

三、虚方法表：动态绑定的底层实现

动态绑定「运行时看实际类型调对应方法」是怎么高效实现的？靠 虚方法表（Virtual Method Table，vtable）：

类加载时，JVM 为每个类建一张虚方法表，记录该类"每个方法的实际入口地址"：
  - 继承父类的方法：如果没重写，表里指向父类的实现；重写了，指向子类自己的实现
  - 方法在表里的位置（下标）是固定的——父类和子类里同一个方法在表中同一个位置

  Animal vtable:  索引0: Animal.sound
  Dog vtable:     索引0: Dog.sound     ← Dog 重写了 sound，索引0 指向 Dog.sound
  Cat vtable:     索引0: Cat.sound     ← Cat 重写了，索引0 指向 Cat.sound

调用 a.sound()（a 实际是 Dog）：
  1. 对象头里有指向"类元信息"的指针 → 找到 Dog 类
  2. 找到 Dog 的 vtable
  3. sound 在表里的位置是固定的索引0 → 取出索引0 的地址 → Dog.sound
  4. 执行 Dog.sound  ✓

vtable 的精妙在于「同一个方法在父类和子类的表里位置相同」——所以编译期虽然不知道实际类型，但知道「sound 在 vtable 的第几个位置」；运行时只要拿到对象实际类的 vtable，按这个固定位置取地址即可。这让动态绑定只需「一次查表」（O(1)），非常高效。字节码里对应 invokevirtual 指令（虚方法调用）。理解「vtable = 每个类一张方法表 + 方法位置固定 + 运行时按对象实际类查表」，就理解了多态高效实现的底层机制。

四、字节码视角：invoke 指令的区别

从字节码看，静态绑定和动态绑定用不同的方法调用指令（前面「字节码」题讲过五条 invoke，这里聚焦绑定）：

invokestatic：调静态方法 → 静态绑定（编译期定，属于类）
invokespecial：调构造器、private 方法、super 方法 → 静态绑定（不参与重写）
invokevirtual：调普通实例方法 → 动态绑定（运行时按实际类型的 vtable 分派）★多态
invokeinterface：调接口方法 → 动态绑定（运行时分派，接口有多个实现）

所以：
  a.sound() 若 sound 是普通实例方法 → invokevirtual → 动态绑定 → 多态
  a.staticMethod() → invokestatic → 静态绑定 → 无多态

关键结论：invokevirtual/invokeinterface 是多态的字节码实现——它们在运行时根据对象的实际类型（通过 vtable/itable）分派到正确的方法；而 invokestatic/invokespecial 是编译期就定死目标的静态绑定。这也印证了前面的分界：能被重写的（普通实例方法、接口方法）走动态绑定有多态，不能被重写的（静态、私有、构造器、super）走静态绑定无多态。理解「invoke 指令区分了静态/动态绑定」，就把「多态的实现」和字节码层面串起来了。

五、重载 vs 重写：两种「多态」的绑定差异

多态常分「编译时多态（重载）」和「运行时多态（重写）」，它们的绑定完全不同，这是高频易混点：

重载（Overload，编译时多态/静态绑定）：
  同名方法、不同参数 → 编译期根据"参数的声明类型"决定调哪个重载版本
  void f(int x) {} 和 void f(String x) {}
  → f(1) 调 f(int)、f("a") 调 f(String)——编译期就定了（看参数声明类型）

重写（Override，运行时多态/动态绑定）：
  子类重写父类方法 → 运行时根据"对象的实际类型"决定调哪个实现
  → 这才是真正的"多态"（vtable 动态分派）

关键区别：重载在编译期按「参数的静态类型」选方法（静态绑定），重写在运行时按「对象的实际类型」选实现（动态绑定）。一个易错例子：

void f(Object o) { print("Object"); }
void f(String s) { print("String"); }
Object obj = "hello";
f(obj);  // 输出"Object"！重载看的是 obj 的"声明类型 Object"，不看实际类型 String

因为重载是静态绑定（编译期按声明类型 Object 选了 f(Object)）。而重写会看实际类型。理解「重载是编译期静态绑定看声明类型、重写是运行时动态绑定看实际类型」，就分清了两种「多态」，也避免了这类易错题。

六、字段和静态方法没有多态

一个必须记住的边界：只有普通实例方法有多态，字段（成员变量）和静态方法都没有多态：

class Parent { String name = "parent"; static String type() { return "P"; } }
class Child extends Parent { String name = "child"; static String type() { return "C"; } }

Parent p = new Child();
System.out.println(p.name);      // "parent"！字段静态绑定，看声明类型 Parent
System.out.println(p.type());    // "P"！静态方法静态绑定，看声明类型 Parent
// 但如果是普通实例方法（可重写），就会看实际类型 Child

原因：字段访问和静态方法调用是静态绑定——字段不存在「重写」概念（子类的同名字段是「隐藏 hide」不是「重写 override」），按引用的声明类型访问；静态方法属于类不属于对象，也按声明类型调（虽然用对象调静态方法本身不推荐）。所以多态只作用于「普通实例方法」。这个边界很容易被忽略，面试常拿「字段有没有多态」考。理解「字段和静态方法是静态绑定、无多态，只有普通实例方法有多态」，就补齐了多态的完整认知——不是「一切都看实际类型」，只有可重写的实例方法才看。

记忆钩子：「多态=同一调用按对象实际类型表现不同行为，靠动态绑定（运行时）实现，底层是虚方法表 vtable（每类一张、方法位置固定、按实际类查表，字节码 invokevirtual）；静态绑定（编译期，static/private/final/构造器、字段、重载）看声明类型无多态；只有普通实例方法有多态，字段和静态方法没有」。

七、常见误区与追问

误区：所有方法调用都是运行时决定的。 只有普通实例方法（可重写的）走动态绑定（运行时看实际类型）；static/private/final 方法、构造器走静态绑定（编译期定），无多态。
误区：字段也有多态。 没有——字段访问是静态绑定，看引用的声明类型（子类同名字段是隐藏不是重写）；只有普通实例方法有多态。
误区：重载也是运行时多态。 重载是编译时多态（静态绑定），编译期按参数的声明类型选方法；只有重写是运行时多态（动态绑定，看实际类型）。
误区：静态方法也能被重写实现多态。 静态方法属于类、是静态绑定，子类同名静态方法是「隐藏」不是重写，按声明类型调用，无多态。
追问：多态的底层是怎么实现的？ 靠虚方法表（vtable）——每个类一张表记录方法的实际入口，同一方法在父子类表里位置固定；调用时通过对象找到实际类的 vtable、按固定位置取地址执行实际类型的方法（字节码 invokevirtual，一次查表 O(1)）。
追问：为什么 static/private/final 方法没有多态？ 它们不能被重写（static 属于类、private 子类看不见、final 禁止重写），不存在「多个版本」，编译期就能确定调哪个，走静态绑定，所以无多态。
追问：f(Object) 和 f(String) 重载，传一个声明为 Object 实际为 String 的变量，调哪个？ 调 f(Object)——重载是静态绑定，编译期按变量的声明类型 Object 选，不看实际类型 String。

八、加强记忆

多态是「同一个方法调用，根据对象的实际类型执行不同实现」（父类引用指向子类对象、调重写的方法），三个前提是继承+重写+父类引用指子类对象，价值是面向抽象编程、消除 if-else、符合开闭原则。它靠动态绑定（运行时绑定） 实现——编译期只定方法签名，运行时看对象实际类型才决定调哪个实现，底层是虚方法表（vtable）：每个类一张表记录方法实际入口、同一方法在父子类表里位置固定，调用时通过对象找到实际类的 vtable、按固定位置查表取地址（字节码 invokevirtual，O(1)）。与之相对的静态绑定（编译期） 用于不能被重写的 static/private/final 方法、构造器、以及字段访问和重载——它们看「声明类型」、无多态。两个关键边界：① 重载是编译时静态绑定（看参数声明类型）、重写是运行时动态绑定（看实际类型）；② 字段和静态方法没有多态，只有普通实例方法有。一句话「多态靠动态绑定+vtable 按实际类型分派、只作用于普通实例方法，static/private/final/字段/重载都是静态绑定看声明类型无多态」。

简化版

详细版