之前我写过《Java 用图形化界面演示 iadd, isub, iconst_<i> 指令的效果》,用 Python + Tkinter 做了个小窗口:七个 iconst_<i> 按钮压常量,iadd / isub 弹栈运算,画布从下往上画出栈。在那篇文章中,我们可以看到值怎么进出操作数栈,比只读规范里的栈变换式更直观。
这次我借助 CodeBuddy 用 Swing 把它重做一遍,沿用前几篇字节码文章积攒的画板代码(帧、字节流、控制流图、无头出图)。重写时改了一处刻意的交互 :旧版让用户点指令按钮自由拼装,容易让人误以为字节码可以在运行时现场拼出来;但 class 文件里的指令在编译完成时就定死了,运行时改不了。所以新版改成选方法 :窗口里是一组编译好的小方法(add1、sub1、calc 等),每个方法的指令清单固定,用户只能改实参 ,再用 Step 一步步看指令怎么操作栈。这样既看到 iconst_<i>、iadd、isub 的效果,又不会误导。
旧版标题带
[Java],代码其实是Python(Tkinter);这版是真正的Java Swing。
三条指令,三句话
JVM 支持 200 多条字节码指令,大多很直白。旧版挑了最基础的几条,规范 6.5 节的栈变换式如下 ⬇️
iconst_<i> (七个指令:iconst_m1、iconst_0、iconst_1、iconst_2、iconst_3、iconst_4、iconst_5)压入 -1 到 5 的 int 常量 ⬇️
text
... → ..., <i>
iadd 弹出栈顶两个 int,相加后压回 ⬇️
text
..., value1, value2 → ..., value1 + value2
isub 同样弹两个,但压回的是差,顺序不能反 ⬇️
text
..., value1, value2 → ..., value1 - value2
value2 是栈顶,value1 是次栈顶。iadd 交换律看不出差别,isub 就露馅了------2 - 7 = -5,不是 7 - 2 = 5。
配套 demo
配套的 OperandStackDemo.java 是一个 Swing 窗口。下载后运行(需 JDK 16+,用到了 record;写本文时我用了 JDK 21)⬇️
bash
javac OperandStackDemo.java
java OperandStackDemo
窗口分三块:
- 左上 :
ShowOps.java源码,当前方法那一行高亮 - 左下:该方法解码后的指令,列出偏移、原始字节、助记符、作用------标题写着 "decoded instructions --- javac output, not editable"
- 右侧 :帧视图,局部变量表和操作数栈(从下往上画),
depth和max_stack都标出来
窗口全英文 ,和前几篇 demo 保持一致。窗口上方是方法下拉框和参数输入框 :选中一个方法,指令清单立刻确定;参数框里只能改实参(默认值 10,calc 默认 2, 3, 4),点 Apply 或按回车重新模拟。Step 单步执行,Run 自动播放(速度可调),Reset 回到 pc = 0。窗口底部是状态栏,用英文解释当前这一步做了什么。
这里没有"点按钮拼指令"这回事------指令是 javac 编译好的,demo 只是把它解码出来给人看。这正是和旧版最大的区别。
颜色约定和前面几篇一样:蓝色是本步压入的值,琥珀色表示本步读取的局部变量。操作数的角色(value1 / value2)从栈上的位置直接读出来------栈顶是 value2,下面一格是 value1,不再用额外的面板重复说明。
方法从哪里来
下拉框里 11 个方法,都是 javac 21 真实编译过的源码。把它们写在一个类里 ⬇️
java
class ShowOps {
int addM1(int a) { return a + (-1); }
int add0(int a) { return a + 0; }
int add1(int a) { return a + 1; }
int add2(int a) { return a + 2; }
int add3(int a) { return a + 3; }
int add4(int a) { return a + 4; }
int add5(int a) { return a + 5; }
int sub1(int a) { return a - 1; }
int sub2(int a) { return a - 2; }
int sub3(int a) { return a - 3; }
int calc(int a, int b, int c) { return a - (b + c); }
}
javap -p -c -v ShowOps 的输出(截取 add3)⬇️
text
int add3(int);
descriptor: (I)I
flags: (0x0000)
Code:
stack=2, locals=2, args_size=2
0: iload_1
1: iconst_3
2: iadd
3: ireturn
每个 addN / subN 都是这个四指令骨架:iload_1、iconst_N、iadd / isub、ireturn。差别只在 iconst_N 那一个字节和最后一条是加还是减。demo 里的字节数组就是照着这些清单写死的,比如 add3 是 1B 06 60 AC,sub3 是 1B 06 64 AC。
calc 稍长,六个指令 ⬇️
text
int calc(int, int, int);
descriptor: (III)I
flags: (0x0000)
Code:
stack=3, locals=4, args_size=4
0: iload_1
1: iload_2
2: iload_3
3: iadd
4: isub
5: ireturn
stack=3 是因为三条 iload 先把三个参数都压上栈,之后才运算------这是旧版那个"压 2、3、4,再 iadd、isub"例子的真实出处。
用 add3 看一遍四个指令
选中 add3,参数 a 保持 10,一路 Step:
第 1 步 iload_1(0x1B) :把局部变量槽 1(也就是 a)的值压栈。操作数栈从空变成 [10],depth = 1 / 2(操作数栈的最大容量是 2 个 slot,现在用了 1 个 slot),a 那一格边框变琥珀色(本步读取)⬇️

第 2 步 iconst_3(0x06) :把常量 3 压栈。规范里写的是 ... → ..., 3,常量体现在 opcode 里,一个字节就能搞定------想压 100 就得换 bipush 100(两个字节,第四篇提过)。栈变成 [10, 3],3 是新压入的,画成蓝色 ⬇️

第 3 步 iadd(0x60) :规范式是 ..., value1, value2 → ..., value1 + value2。栈顶那格 3 是 value2,下面一格 10 是 value1,两格一起消失,新压入的 13 画成蓝色。栈从 [10, 3] 变成 [13],depth = 1 / 2 ⬇️

第 4 步 ireturn(0xAC) :弹出 13 返回,方法结束。帧视图底部出现绿色的 returned 13 to the caller,这就是 add3(10) 的结果。
七个 iconst_<i> 指令各有一个 addN 方法对应(addM1 到 add5),iconst_m1 到 iconst_5 全覆盖。下拉框里切一下,左下角指令清单的第二个字节就从 02 变到 08,其他三行不动------一个字节的差别,结果从 a-1 变成 a+5。
用 calc 看 isub 的顺序
旧版最要紧的是 isub 的顺序问题。calc(a, b, c) { return a - (b + c); } 默认参数 a=2, b=3, c=4,正好重现旧版的 2 - (3 + 4)。
前三步 iload_1、iload_2、iload_3 把 2、3、4 依次压栈,depth = 3 / 3 用满。第 4 步 iadd 弹出栈顶的 4(value2)和下面的 3(value1),压回 7,栈变成 [2, 7] ⬇️

第 5 步 isub:栈顶 7 是 value2,下面一格 2 是 value1,压回 2 - 7 = -5------value1 - value2,不是反过来。栈只剩 [-5],depth = 1 / 3 ⬇️

把 calc 的参数换成 a=7, b=2, c=0 再点一遍,isub 那步就变成 7 - 2 = 5------字节码一字没改,只因为实参不同,结果就翻了符号 。这正是"指令固定、数据可变"的意思:编译期定下来的是算法(a - (b+c)),运行期传进来的参数决定算出什么数。
和旧版的第一个不同:指令也显示字节
旧版的 Tkinter 画布只画栈,按钮上写助记符就行。我们已经花了一篇讲"一条指令 = 1 字节 opcode + 可选操作数",所以这版给每条指令标了 opcode ⬇️
| 指令 | opcode | 字节数 | 值/操作数放在哪 |
|---|---|---|---|
iconst_m1 |
0x02 |
1 | 值 -1 编在 opcode 里 |
iconst_0 |
0x03 |
1 | 值 0 编在 opcode 里 |
iconst_1 |
0x04 |
1 | 值 1 编在 opcode 里 |
iconst_2 |
0x05 |
1 | 值 2 编在 opcode 里 |
iconst_3 |
0x06 |
1 | 值 3 编在 opcode 里 |
iconst_4 |
0x07 |
1 | 值 4 编在 opcode 里 |
iconst_5 |
0x08 |
1 | 值 5 编在 opcode 里 |
iadd |
0x60 |
1 | 无操作数,值都在栈上 |
isub |
0x64 |
1 | 无操作数,值都在栈上 |
iload_1 |
0x1B |
1 | 局部变量槽号编在 opcode 里 |
iload_2 |
0x1C |
1 | 局部变量槽号编在 opcode 里 |
iload_3 |
0x1D |
1 | 局部变量槽号编在 opcode 里 |
ireturn |
0xAC |
1 | 弹出栈顶返回 |
左下角指令面板里每行都有这些字节。add3 那四行是 1B、06、60、AC,四个字节对应四条指令;换成 add5 只动第二个字节(06 → 08)。
和旧版的第二个不同:把 max_stack 画出来
Tkinter 版只关心栈里现在有什么。前面几篇反复出现过 javap 输出里的 stack= 和 locals=,这里顺手把 max_stack 也带上:栈面板底部写着 depth = N / M,M 就是该方法的 max_stack。
addN / subN 的 M = 2------压完局部变量和常量,栈深到 2,再 iadd / isub 弹二压一回到 1。calc 的 M = 3:三个 iload 连压,栈深到 3 才开始运算。
max_stack 是编译期算好写进 Code 属性的,运行期不会变。参数从 10 改成 1000000,depth 的轨迹一模一样,M 也不变------类型决定占几个 slot,指令序列决定深度怎么变,和具体数值无关 。这也是为什么把交互从"点指令"改成"选方法"更诚实:max_stack 是和固定指令序列绑定的,现场拼指令就没法谈 max_stack 了。
动手题:换成 sub3
选中 sub3,把参数 a 改成 5,先自己点一遍,再对答案 ⬇️
iload_1:压入5,栈[5]iconst_3:压入3,栈[5, 3]isub:value2 = 3(栈顶),value1 = 5(次栈顶),压回5 - 3 = 2ireturn:返回2
再把 a 改成 1:同样三步,结果变成 1 - 3 = -2。iconst_3 那条指令没变,isub 那条也没变,变的只有 iload_1 从局部变量槽里取出来的值。
最后把 a 改成 10 对比 add3:两条方法的指令清单只差第三个字节------add3 是 60(iadd),sub3 是 64(isub);10 + 3 = 13,10 - 3 = 7。一个字节的差别。
小结
iconst_<i>是七条指令(iconst_m1到iconst_5),把-1到5编进 opcode,一条指令一个字节压栈,不需要操作数。iadd/isub弹出栈顶两个int,压回value1 + value2/value1 - value2;value2是栈顶,value1是次栈顶。- 减法的顺序不能反 :
isub算的是次栈顶减栈顶,2 - 7 = -5,不是7 - 2。 - 操作数栈从下往上长 :新压入的值在栈顶,算术指令只动栈顶的两个值,
stack深度随之减一。 - 编译期定的是指令序列和
max_stack,运行期变的是实参。GUI 让用户选方法、改参数,正好对应这条边界------既看到指令怎么操作栈,又不会误以为字节码能现场拼装。
这版和一个纯"点按钮看效果"的版本相比,多了一层真实感:每个方法都来自 javap 的真实输出,字节、栈深、返回值都能对上。图形化不能替代读规范,但能把"弹出两个、压回一个"这句抽象的话,变成眼睛看得见的三步------前提是别把指令画成可以随便点的玩具。