本文原创，转载请注明出处。关注博主，持续分享Java进阶知识。

一、开篇：一个可变长参数的”坑”

先来看一个有趣的代码片段：

void invoke(Object obj, Object... args) { ... }
void invoke(String s, Object obj, Object... args) { ... }
​
invoke(null, 1);    // 调用第二个 invoke 方法 ❓
invoke(null, 1, 2); // 调用第二个 invoke 方法 ❓
invoke(null, new Object[]{1}); // 调用第一个 invoke 方法 ✅

为什么 invoke(null, 1) 会调用第二个方法？明明第一个方法的签名更匹配啊！

这个问题的答案，藏在Java方法调用的底层机制之中。今天，就让我们一起揭开JVM方法调用的神秘面纱！

---

二、重载与重写：Java语言层面的方法识别

2.1 方法重载（Overload）

定义： 同一个类中，方法名相同但参数类型不同的方法之间的关系

编译器的选择逻辑：

阶段1：不考虑自动装拆箱和可变长参数
    ↓ 未找到
阶段2：允许自动装拆箱，不允许可变长参数
    ↓ 未找到
阶段3：允许自动装拆箱和可变长参数

关键原则： 形式参数类型的继承关系决定贴切程度

// 示例：null参数的匹配
void invoke(Object obj, Object... args) { ... }     // 方法1
void invoke(String s, Object obj, Object... args) { ... } // 方法2
​
invoke(null, 1);  // null既可以匹配Object，也可以匹配String
                  // String是Object的子类，所以方法2更贴切

2.2 方法重写（Override）

定义： 子类定义与父类非私有方法同名、同参数类型的方法

重写 vs 隐藏：

场景	关系类型	说明
子类静态方法 vs 父类静态方法	隐藏（Hide）	调用时看声明类型
子类实例方法 vs 父类实例方法	重写（Override）	调用时看实际类型

重写的多态体现：

class Animal {
    void makeSound() { System.out.println("Animal"); }
}
​
class Dog extends Animal {
    @Override
    void makeSound() { System.out.println("Woof!"); }
}
​
Animal animal = new Dog();
animal.makeSound();  // 输出"Woof!"，根据实际类型调用

---

三、JVM层面的方法识别

3.1 方法描述符（Method Descriptor）

JVM识别方法的三要素：类名 + 方法名 + 方法描述符

方法描述符 = 参数类型列表 + 返回类型
​
示例：
void invoke(Object obj, Object... args)
→ 描述符：(Ljava/lang/Object;[Ljava/lang/Object;)V
​
double actionPrice(double price, Customer customer)
→ 描述符：(DLcom/example/Customer;)D

注意： JVM允许方法名和参数类型相同但返回类型不同的方法存在！

3.2 JVM的重写判定规则

JVM判定重写的条件：

• 方法名相同
• 参数类型相同（方法描述符中的参数部分）
• 返回类型也必须相同

// Java语言中合法的重写，但JVM不认为是重写
class Parent {
    Number getValue() { return 1; }
}
​
class Child extends Parent {
    @Override
    Integer getValue() { return 2; }  // 返回类型不同
}

解决方案： 编译器生成桥接方法（Bridge Method）

// 编译器自动生成的桥接方法
class Child extends Parent {
    // 桥接方法：调用实际实现
    Number getValue() {
        return this.getValue();  // 调用下面的Integer版本
    }
    
    // 实际实现
    Integer getValue() {
        return 2;
    }
}

---

四、静态绑定与动态绑定

4.1 五种方法调用指令

指令	用途	绑定类型
invokestatic	调用静态方法	静态绑定
invokespecial	调用私有方法、构造器、super调用	静态绑定
invokevirtual	调用非私有实例方法	动态绑定
invokeinterface	调用接口方法	动态绑定
invokedynamic	调用动态方法（Lambda等）	动态绑定

4.2 指令示例

interface Customer {
    boolean isVIP();  // invokeinterface
}
​
class Merchant {
    public double discountPrice(double price, Customer customer) {
        return price * 0.8d;
    }
}
​
class ShadyMerchant extends Merchant {
    @Override
    public double discountPrice(double price, Customer customer) {
        if (customer.isVIP()) {           // invokeinterface
            return price * priceDiscrimination();  // invokestatic
        } else {
            return super.discountPrice(price, customer);  // invokespecial
        }
    }
    
    public static double priceDiscrimination() {
        return new Random()           // invokespecial (构造器)
               .nextDouble() + 0.8d;  // invokevirtual
    }
}

4.3 静态绑定 vs 动态绑定

静态绑定（解析时确定）：

• invokestatic：静态方法，类加载后地址固定
• invokespecial：私有方法/构造器/super调用，目标明确

动态绑定（运行时确定）：

• invokevirtual：非私有实例方法，需根据调用者实际类型查找
• invokeinterface：接口方法，需根据实现类查找

例外情况： 如果方法被标记为 final，JVM可以直接确定目标方法，无需动态绑定。

---

五、符号引用的解析过程

5.1 符号引用的结构

符号引用 = 类/接口名 + 方法名 + 方法描述符

示例（常量池中的表示）：
#16 = InterfaceMethodref #27.#29    // Customer.isVIP:()Z
#22 = Methodref          #1.#33     // ShadyMerchant.priceDiscrimination:()D

5.2 非接口符号引用的解析

假设符号引用指向类C：

步骤1：在C中查找匹配方法（方法名+描述符）
    ↓ 未找到
步骤2：在C的父类中递归查找，直至Object类
    ↓ 未找到
步骤3：在C实现的接口中查找（非私有、非静态）

特点： 静态方法可以通过子类调用，子类静态方法会隐藏父类同名方法。

5.3 接口符号引用的解析

假设符号引用指向接口I：

步骤1：在I中查找匹配方法 ↓ 未找到 步骤2：在Object类的公有实例方法中查找 ↓ 未找到 步骤3：在I的超接口中递归查找

5.4 解析结果

绑定类型	实际引用形式
静态绑定	指向方法的指针（直接地址）
动态绑定	方法表的索引（运行时查表）

---

六、实战：桥接方法的奥秘

6.1 场景一：返回类型协变

interface Customer {
    boolean isVIP();
}

class Merchant {
    public Number actionPrice(double price, Customer customer) {
        return price;
    }
}

class NaiveMerchant extends Merchant {
    @Override
    public Double actionPrice(double price, Customer customer) {
        return price * 0.8;
    }
}

编译后生成的桥接方法：

class NaiveMerchant extends Merchant {
    // 编译器生成的桥接方法
    public Number actionPrice(double price, Customer customer) {
        return this.actionPrice(price, customer);  // 调用Double版本
    }
    
    // 实际实现
    public Double actionPrice(double price, Customer customer) {
        return price * 0.8;
    }
}

6.2 场景二：泛型类型擦除

interface Customer {}
interface VIP extends Customer {}

class Merchant<T extends Customer> {
    public double actionPrice(double price, T customer) {
        return price;
    }
}

class VIPOnlyMerchant extends Merchant<VIP> {
    @Override
    public double actionPrice(double price, VIP customer) {
        return price * 0.7;
    }
}

编译后（泛型擦除）：

class Merchant {
    public double actionPrice(double price, Customer customer) { ... }
}

class VIPOnlyMerchant extends Merchant {
    // 编译器生成的桥接方法
    public double actionPrice(double price, Customer customer) {
        return this.actionPrice(price, (VIP) customer);
    }
    
    // 实际实现
    public double actionPrice(double price, VIP customer) {
        return price * 0.7;
    }
}

6.3 验证方法

使用 javap -v 查看class文件：

$ javac NaiveMerchant.java
$ javap -v NaiveMerchant.class

---

七、总结

核心要点回顾

1. 方法重载：编译期确定，根据参数类型和继承关系选择
2. 方法重写：运行期确定，根据调用者实际类型选择
3. 方法描述符：JVM识别方法的关键，包含参数类型和返回类型
4. 五种调用指令：invokestatic、invokespecial、invokevirtual、invokeinterface、invokedynamic
5. 静态绑定：解析时确定目标方法（invokestatic、invokespecial）
6. 动态绑定：运行时确定目标方法（invokevirtual、invokeinterface）
7. 桥接方法：编译器生成，解决Java语言重写与JVM重写的差异

关键理解

• Java编译器在编译期完成重载方法的选择
• JVM在解析期完成静态绑定方法的地址确定
• JVM在运行期通过方法表完成动态绑定方法的查找
• 桥接方法是Java语言特性与JVM实现之间的桥梁

---

写在最后

方法调用是Java程序执行的核心，深入理解其底层机制对于写出高效代码和排查问题至关重要。下一篇，我将详细介绍方法表的实现原理，以及动态绑定的具体过程。

如果觉得本文对你有帮助，欢迎点赞、收藏、关注！后续我会继续分享更多JVM相关的深度解析文章。

📚 关注我，一起深入探索Java虚拟机的奥秘！