元数据卡

• 前置知识：Vol 3 计算机系统（指令集、寄存器、栈的概念）、Vol 9 第1-2章（类型与运行时）
• 预计时间：50 分钟
• 核心难度：黑魔法
• 阅读模式：高度专注
• 可选跳过：指令集枚举可略读，关注方法调用和异常处理即可
• 完成标志：能用 javap 反编译 class 文件并读懂核心字节码；理解方法调用指令的区别

你的进度

你在遗迹里发现了一个密室——房间正中放着一台老式投影仪。玻璃片上映出的不是代码，而是 Java 编译器吐出的二进制中间产物：字节码。你在墙上找到了老陈的笔记，白纸黑字写着："不理解字节码，就不理解 Java。"

你的任务

你写的 .java 文件经过编译变成 .class 文件，然后被 JVM 加载执行。如果你只看 .java 层面的语法，你永远不知道编译器在背后干了什么——泛型擦除、语法糖、装箱拆箱、字符串拼接的优化。本章让你亲眼看看反编译结果，读懂字节码。

本章分层

• 必读：类文件结构概览、javap 使用、常见的字节码指令
• 选读：方法调用指令详解（invokevirtual/invokespecial/invokeinterface/invokestatic）
• 进阶：异常表结构、Lambda 表达式在字节码中的实现

破局 · 溯源

你在 Java 源码里写了：

String s = "hello" + "world";

编译器会优化成 "helloworld"，还是运行时拼接？你不知道。但你把它编译成 class 文件，然后反编译看看就知道了：

javac Hello.java
javap -c Hello

输出像这样：

0: ldc           #7                  // String helloworld
2: astore_1
3: return

编译器直接把拼接结果算好了——ldc #7 加载常量池中的 "helloworld" 字符串。这就是字节码给你看的真相。

---

类文件结构概览

一个 .class 文件包含以下部分：

ClassFile {
    u4             magic;                // 0xCAFEBABE
    u2             minor_version;
    u2             major_version;        // 65 = Java 21
    u2             constant_pool_count;
    cp_info        constant_pool[constant_pool_count-1];
    u2             access_flags;         // public, final, abstract...
    u2             this_class;
    u2             super_class;
    u2             interfaces_count;
    u2             interfaces[interfaces_count];
    u2             fields_count;
    field_info     fields[fields_count];
    u2             methods_count;
    method_info    methods[methods_count];
    u2             attributes_count;
    attribute_info attributes[attributes_count];
}

用 javap -v Hello（verbose 模式）能看到完整结构。但你不需要全部记住——只需要知道：

• 常量池：所有字符串、类名、方法名、字段名的符号表
• 方法：字节码指令 + 异常表 + 行号表
• 属性：注解、泛型签名、内部类信息等

常量池是 JVM 的"字典"。所有的指令都引用常量池中的索引，而不是直接写字符串。这样设计有两个好处：指令长度固定（2 字节索引），且常量可以被多条指令共享。

---

栈式虚拟机：指令集

JVM 是基于栈的虚拟机。不是寄存器、不是累加器——每条指令在操作数栈上处理。

int add(int a, int b) {
    return a + b;
}

反编译：

0: iload_1       // 把局部变量 1 (a) 压栈
1: iload_2       // 把局部变量 2 (b) 压栈
2: iadd          // 弹出两个值，相加，结果压栈
3: ireturn       // 弹出栈顶值返回

操作数栈不是寄存器。iadd 没有"去哪个寄存器取"的参数——它从栈顶取两个值。这就是"基于栈"的含义。

JVM 为什么选择栈架构？ 栈的指令编码比寄存器更紧凑（每个指令不需要指定寄存器编号），跨平台时指令集不需要改。代价是需要更多的 load/store 指令——把局部变量从变量表搬到栈上、再搬回去。

对比 x86 的寄存器架构（你不需要会 x86 汇编，只是感受区别）：

; x86 — 直接在寄存器上操作
mov eax, [a]    ; 从内存 a 到寄存器 eax
add eax, [b]    ; eax = eax + b
; 结果就在 eax 中

JVM 需要多余的 load 步骤，但换来的是指令集架构独立于任何物理 CPU。

---

常用指令速览

类型	指令	作用
加载	iload, aload, fload	把局部变量压栈
存储	istore, astore, fstore	弹出栈顶值到局部变量
运算	iadd, isub, imul, idiv	弹出两个值运算后压栈
对象	new, getfield, putfield	创建对象、读写字段
方法	invokevirtual, invokespecial	调用方法
返回	ireturn, areturn, return	返回各种类型

---

方法调用指令的学问

Java 有四种方法调用指令，每种用在不同场景。这是理解"多态在字节码层怎么实现"的关键。

invokevirtual：实例方法，动态分派

void call(Animal a) {
    a.speak();  // invokevirtual
}

反编译：

0: aload_1
1: invokevirtual #12  // Method Animal.speak()V

invokevirtual 是动态分派的：运行时根据 a 的实际类型查找方法表。如果 a 是 Dog，调用 Dog.speak()；是 Cat，调用 Cat.speak()。

字节码层面并不关心实际类型——它只是说"从运行时的类开始，往上找 speak 的实现"。

invokespecial：构造器、私有方法、父类方法

class B extends A {
    B() {
        super();  // invokespecial
    }

    private void helper() {}  // 调用者：invokespecial
}

invokespecial 不做动态分派——编译器已经确定调哪个方法。构造器调用 super() 是固定的，私有方法不会被重写。

invokestatic：静态方法

int x = Math.max(3, 5);  // invokestatic

最直接——不用实例、不用分派。

invokeinterface：接口方法

跟 invokevirtual 类似，但 JVM 需要走接口方法表（itable）而不是虚方法表（vtable）。理论上略慢一点——实践中几乎不可感知。

void call(List list) {
    list.size();  // invokeinterface
}

四种指令对比：

指令	目标	分派方式	典型场景
invokevirtual	实例方法	运行时动态	obj.toString()
invokespecial	构造器/私有/父类	编译期确定	super(), private void
invokestatic	静态方法	编译期确定	Math.max()
invokeinterface	接口方法	运行时动态（查找 itable）	list.size()

---

异常表

try-catch 在字节码中不是"指令"，而是异常表：

void readFile(String path) {
    try {
        FileInputStream fis = new FileInputStream(path);
    } catch (IOException e) {
        System.out.println("error");
    }
}

反编译看到异常表：

Exception table:
   from    to  target type
       0    16    19   Class java/io/IOException

意思：从字节码偏移 0 到 16 之间的代码，如果抛出 IOException，就跳到偏移 19 执行。

finally 怎么实现？ finally 块在字节码中被复制多次——放在正常路径末尾，也放在每个 catch 块的末尾。编译器确保不论正常返回还是异常，这里的代码都会被执行。

try {
    // ...
} finally {
    cleanup();  // 字节码中出现了两次
}

你可以用 javap 验证这一点——你会在异常表中看到 finally 的代码以"最终处理"方式出现。

---

额外探索：Lambda 的字节码

list.forEach(x -> System.out.println(x));

Lambda 不是匿名内部类。字节码层面，编译器生成了一个 invokedynamic 指令，运行时通过 LambdaMetafactory 生成函数式接口的实例。

// 反编译出来的 (javap -v)
0: aload_0
1: invokedynamic #7, 0  // InvokeDynamic #0:accept:()Ljava/util/function/Consumer;

invokedynamic 是 Java 7 引入的指令，Java 8 的 Lambda 成为它的头号用户。原因是：invokedynamic 允许在运行时确定具体的调用目标——Lambda 在启动时只生成一次，后续直接复用，性能优于匿名类。

---

常见陷阱

1. "看字节码=学汇编" —— JVM 指令集只有约 200 条指令（常用 ~30 条），比 x86（上千条）少得多
2. "String + 操作每次都创建对象" —— 编译器和 JIT 会优化（字符串拼接优化、StringBuilder 自动使用），但循环内拼接仍有陷阱
3. "所有异常都要检查字节码" —— 不，只是为了理解 finally 复制、你不需要记指令表，只需要会读 javap 输出

通关挑战

• 热身：写一个简单的 Java 类（只有 add 方法），用 javap -c 反编译，指出每一行的含义
• 动手：写一个带 try-catch-finally 的方法，分别反编译，验证 finally 被复制了几次
• 观察：对比 String s = "a" + "b" 和 String s = "a"; String t = s + "b" 两种写法的字节码差异——你能看出编译器在什么条件下做编译期折叠吗？

旅人笔记

字节码是 Java 编译器的"实话实说"——你不问它，它就假装语法糖是真的。你一 javap，它就把泛型擦除、字符串折叠、finally 复制的真相全交代了。

→ 下一站预告

你终于可以看清 Java 的底牌了。但还有更远的路——有些语言不满足于编译器给什么就用什么，它们想自己造编译器的活。第六扇门：元编程与 DSL——写代码的代码。