目录

一、简单demo分析

字节码文件信息

常量池

方法表集合

二、分析try-catch-finally的demo

计算机只认识0和1。这意味着任何语言编写的程序最终都需要经过编译器编译成机器码才能被计算机执行。所以，我们所编写的程序在不同的平台上运行前都要经过重新编译才能被执行。 而Java刚诞生的时候曾经提过一个非常著名的宣传口号: "一次编写，到处运行"。为了实现该目的，Sun公司以及其他虚拟机提供商发布了许多可以运行在不同平台上的JVM虚拟机，而这些虚拟机都拥有一个共同的功能，那就是可以载入和执行同一种与平台无关的字节码(ByteCode)。 于是，我们的源代码不再必须根据不同平台翻译成0和1，而是间接翻译成字节码，储存字节码的文件再交由运行于不同平台上的JVM虚拟机去读取执行，从而实现一次编写，到处运行的目的。 如今，JVM也不再只支持Java，由此衍生出了许多基于JVM的编程语言，如Groovy, Scala, Koltin等等。

源代码中的各种变量，关键字和运算符号的语义最终都会编译成多条字节码命令。而字节码命令所能提供的语义描述能力是要明显强于Java本身的，所以有其他一些同样基于JVM的语言能提供许多Java所不支持的语言特性。

一、简单demo分析

下面以一个简单的例子来逐步讲解字节码。

public class Main {
private int m;
public int inc() {
return m + 1;
}
}

通过以下命令, 可以在当前所在路径下生成一个Main.class 文件。以文本的形式打开生成的class文件，内容如下:

文件中的为16进制代码， 文件开头的4个字节称之为 魔数，唯有以"cafe babe"开头的class文件方可被虚拟机所接受，这4个字节就是字节码文件的身份识别。0000是编译器jdk版本的次版本号0，0034转化为十进制是52,是主版本号，java的版本号从45开始，除1.0和1.1都是使用45.x外,以后每升一个大版本，版本号加一。也就是说，编译生成该class文件的jdk版本为
1.8.0。 通过java -version 命令稍加验证, 可得结果。

结果验证成立。
继续往下是常量池。但我并不打算继续直接分析这个十六进制文件。

反编译字节码文件
使用到java内置的一个反编译工具javap 可以反编译字节码文件。 通过javap -help 可了解javap的基本用法

输入命令javap -verbose -p Main.class 查看输出内容:

 
E:\20180807_learn>javap -v -p Main.class
Classfile /E:/20180807_learn/Main.classLast modified 2018-8-7; size 265 bytesMD5 checksum db7ad8ef61aa899dd0a8b9516155244eCompiled from "Main.java"
public class Mainminor version: 0major version: 52flags: ACC_PUBLIC, ACC_SUPER
Constant pool:#1 = Methodref          #4.#15         // java/lang/Object."<init>":()V#2 = Fieldref           #3.#16         // Main.m:I#3 = Class              #17            // Main#4 = Class              #18            // java/lang/Object#5 = Utf8               m#6 = Utf8               I#7 = Utf8               <init>#8 = Utf8               ()V#9 = Utf8               Code#10 = Utf8               LineNumberTable#11 = Utf8               inc#12 = Utf8               ()I#13 = Utf8               SourceFile#14 = Utf8               Main.java#15 = NameAndType        #7:#8          // "<init>":()V#16 = NameAndType        #5:#6          // m:I#17 = Utf8               Main#18 = Utf8               java/lang/Object
{private int m;descriptor: Iflags: ACC_PRIVATEpublic Main();descriptor: ()Vflags: ACC_PUBLICCode:stack=1, locals=1, args_size=10: aload_01: invokespecial #1                  // Method java/lang/Object."<init>
":()V4: returnLineNumberTable:line 1: 0public int inc();descriptor: ()Iflags: ACC_PUBLICCode:stack=2, locals=1, args_size=10: aload_01: getfield      #2                  // Field m:I4: iconst_15: iadd6: ireturnLineNumberTable:line 4: 0
}
SourceFile: "Main.java"

字节码文件信息

开头的7行信息包括:Class文件当前所在位置，最后修改时间，文件大小，MD5值，编译自哪个文件，类的全限定名，jdk次版本号，主版本号。 然后紧接着的是该类的访问标志：ACC_PUBLIC, ACC_SUPER，访问标志的含义如下:

常量池
Constant pool 意为常量池。 常量池可以理解成Class文件中的资源仓库。主要存放的是两大类常量：字面量(Literal)和符号引用(SymbolicReferences)。字面量类似于java中的常量概念，如文本字符串，final常量等，而符号引用则属于编译原理方面的概念，包括以下三种:
1）、类和接口的全限定名(Fully Qualified Name)
2）、字段的名称和描述符号(Descriptor)
3）、方法的名称和描述符
不同于C/C++, JVM是在加载Class文件的时候才进行的动态链接，也就是说这些字段和方法符号引用只有在运行期转换后才能获得真正的内存入口地址。当虚拟机运行时，需要从常量池获得对应的符号引用，再在类创建或运行时解析并翻译到具体的内存地址中。
直接通过反编译文件来查看字节码内容：
#1 = Methodref          #4.#15         // java/lang/Object."<init>":()V
#4 = Class              #18            // java/lang/Object
#7 = Utf8               <init>
#8 = Utf8               ()V
#15 = NameAndType        #7:#8          // "<init>":()V
#18 = Utf8               java/lang/Object

第一个常量是一个方法定义，指向了第4和第15个常量。以此类推查看第4和第15个常量。最后可以拼接成第一个常量右侧的注释内容:

java/lang/Object."<init>":()V

这段可以理解为该类的实例构造器的声明，由于Main类没有重写构造方法，所以调用的是父类的构造方法。此处也说明了Main类的直接父类是Object。 该方法默认返回值是V, 也就是void，无返回值。

同理可分析第二个常量:

#2 = Fieldref           #3.#16         // Main.m:I
#3 = Class              #17            // Main
#5 = Utf8               m
#6 = Utf8               I
#16 = NameAndType        #5:#6          // m:I
#17 = Utf8               Main

此处声明了一个字段m，类型为I, I即是int类型。关于字节码的类型对应如下：

对于数组类型，每一位使用一个前置的"["字符来描述，如定义一个java.lang.String[][]类型的维数组，将被记录为"[[Ljava/lang/String;"

方法表集合
在常量池之后的是对类内部的方法描述，在字节码中以表的集合形式表现，暂且不管字节码文件的16进制文件内容如何，我们直接看反编译后的内容。

private int m;
descriptor: I
flags: ACC_PRIVATE

此处声明了一个私有变量m，类型为int，返回值为int

public Main();descriptor: ()Vflags: ACC_PUBLICCode:stack=1, locals=1, args_size=10: aload_01: invokespecial #1                  // Method java/lang/Object."<init>":()V4: returnLineNumberTable:line 1: 0

这里是构造方法：Main()，返回值为void, 公开方法。 code内的主要属性为:

• stack 最大操作数栈，JVM运行时会根据这个值来分配栈帧(Frame)中的操作栈深度,此处为1
• locals: 局部变量所需的存储空间，单位为Slot, Slot是虚拟机为局部变量分配内存时所使用的最小单位，为4个字节大小。方法参数(包括
• 实例方法中的隐藏参数this)，显示异常处理器的参数(try catch中的catch块所定义的异常)，方法体中定义的局部变量都需要使用局部变量表来存放。值得一提的是，locals的大小并不一定等于所有局部变量所占的Slot之和，因为局部变量中的Slot是可以重用的。
• args_size: 方法参数的个数，这里是1，因为每个实例方法都会有一个隐藏参数this
• attribute_info 方法体内容，0,1,4为字节码"行号"，该段代码的意思是将第一个引用类型本地变量推送至栈顶，然后执行该类型的实例方法，也就是常量池存放的第一个变量，也就是注释里的"java/lang/Object."":()V", 然后执行返回语句，结束方法。
• LineNumberTable 该属性的作用是描述源码行号与字节码行号(字节码偏移量)之间的对应关系。可以使用 -g:none 或-g:lines选项来取消或要求生成这项信息，如果选择不生成LineNumberTable，当程序运行异常时将无法获取到发生异常的源码行号，也无法按照源码的行数来调试程序。
• LocalVariableTable 该属性的作用是描述帧栈中局部变量与源码中定义的变量之间的关系。可以使用 -g:none 或 -g:vars来取消或生成这项信息，如果没有生成这项信息，那么当别人引用这个方法时，将无法获取到参数名称，取而代之的是arg0, arg1这样的占位符。start 表示该局部变量在哪一行开始可见，length表示可见行数，Slot代表所在帧栈位置，Name是变量名称，然后是类型签名。

同理可以分析Main类中的另一个方法"inc()": 方法体内的内容是：将this入栈，获取字段#2, 将int类型的1入栈，将栈内顶部的两个数值相加，返回一个int类型的值。

SourceFile  源码文件名称

二、分析try-catch-finally的demo
通过以上一个最简单的例子，可以大致了解源码被编译成字节码后是什么样子的。 下面利用所学的知识点来分析一些Java问题:

public class TestCode {
public int foo() {
int x;
try {
x = 1;
return x;
} catch (Exception e) {
x = 2;
return x;
} finally {
x = 3;
}
}
}

E:\20180807_learn>javap -v -p TestCode.class
Classfile /E:/20180807_learn/TestCode.classLast modified 2018-8-7; size 417 bytesMD5 checksum 388303755886516af0472f05542c886aCompiled from "TestCode.java"
public class TestCodeminor version: 0major version: 52flags: ACC_PUBLIC, ACC_SUPER
Constant pool:#1 = Methodref          #4.#16         // java/lang/Object."<init>":()V#2 = Class              #17            // java/lang/Exception#3 = Class              #18            // TestCode#4 = Class              #19            // java/lang/Object#5 = Utf8               <init>#6 = Utf8               ()V#7 = Utf8               Code#8 = Utf8               LineNumberTable#9 = Utf8               foo#10 = Utf8               ()I#11 = Utf8               StackMapTable#12 = Class              #17            // java/lang/Exception#13 = Class              #20            // java/lang/Throwable#14 = Utf8               SourceFile#15 = Utf8               TestCode.java#16 = NameAndType        #5:#6          // "<init>":()V#17 = Utf8               java/lang/Exception#18 = Utf8               TestCode#19 = Utf8               java/lang/Object#20 = Utf8               java/lang/Throwable
{public TestCode();descriptor: ()Vflags: ACC_PUBLICCode:stack=1, locals=1, args_size=10: aload_01: invokespecial #1                  // Method java/lang/Object."<init>
":()V4: returnLineNumberTable:line 1: 0public int foo();descriptor: ()Iflags: ACC_PUBLICCode:stack=1, locals=5, args_size=10: iconst_11: istore_12: iload_13: istore_24: iconst_35: istore_16: iload_27: ireturn8: astore_29: iconst_210: istore_111: iload_112: istore_313: iconst_314: istore_115: iload_316: ireturn17: astore        419: iconst_320: istore_121: aload         423: athrowException table:from    to  target type0     4     8   Class java/lang/Exception0     4    17   any8    13    17   any17    19    17   anyLineNumberTable:line 5: 0line 6: 2line 11: 4line 6: 6line 7: 8line 8: 9line 9: 11line 11: 13line 9: 15line 11: 17StackMapTable: number_of_entries = 2frame_type = 72 /* same_locals_1_stack_item */stack = [ class java/lang/Exception ]frame_type = 72 /* same_locals_1_stack_item */stack = [ class java/lang/Throwable ]
}
SourceFile: "TestCode.java"

试问当不发生异常和发生异常的情况下，foo()的返回值分别是多少。 使出老手段

javac TestCode.java
javap -verbose TestCode.class

查看字节码的foo方法内容:

public int foo();
descriptor: ()I
flags: ACC_PUBLIC
Code:
stack=1, locals=5, args_size=1
0: iconst_1 //int型1入栈 ->栈顶=1
1: istore_1 //将栈顶的int型数值存入第二个局部变量 ->局部2=1
2: iload_1 //将第二个int型局部变量推送至栈顶 ->栈顶=1
3: istore_2 //!!将栈顶int型数值存入第三个局部变量 ->局部3=1
4: iconst_3 //int型3入栈 ->栈顶=3
5: istore_1 //将栈顶的int型数值存入第二个局部变量 ->局部2=3
6: iload_2 //!!将第三个int型局部变量推送至栈顶 ->栈顶=1
7: ireturn //从当前方法返回栈顶int数值 ->1
8: astore_2 // ->局部3=Exception
9: iconst_2 // ->栈顶=2
10: istore_1 // ->局部2=2
11: iload_1 //->栈顶=2
12: istore_3 //!! ->局部4=2
13: iconst_3 // ->栈顶=3
14: istore_1 // ->局部1=3
15: iload_3 //!! ->栈顶=2
16: ireturn // -> 2
17: astore 4 //将栈顶引用型数值存入第五个局部变量=any19: iconst_3 //将int型数值3入栈 -> 栈顶3
20: istore_1 //将栈顶第一个int数值存入第二个局部变量 -> 局部2=3
21: aload 4 //将局部第五个局部变量(引用型)推送至栈顶
23: athrow //将栈顶的异常抛出
Exception table:
from to target type
0 4 8 Class java/lang/Exception //0到4行对应的异常，对应#8中储存的异常
0 4 17 any //Exeption之外的其他异常
8 13 17 any
17 19 17 any

在字节码的4,5，以及13,14中执行的是同一个操作，就是将int型的3入操作数栈顶，并存入第二个局部变量。这正是我们源码在finally语句块中内容。也就是说，JVM在处理异常时，会在每个可能的分支都将finally语句重复执行一遍。 通过一步步分析字节码，可以得出最后的运行结果是：

• 不发生异常时: return 1
• 发生异常时: return 2
• 发生非Exception及其子类的异常，抛出异常，不返回值

以上例子来自于《深入理解Java虚拟机 JVM高级特性与最佳实践》 关于虚拟机字节码指令表，也可以在《深入理解Java虚拟机 JVM高级特性与最佳实践-附录B》中获取。

kotlin 函数扩展的实现
kotlin提供了扩展函数的语言特性，借助这个特性，我们可以给任意对象添加自定义方法。 以下示例为Object添加"sayHello"方法

//SayHello.kt
package com.rhythm7
fun Any.sayHello() {
println("Hello")
}

编译后，使用javap查看生成SayHelloKt.class文件的字节码。

Classfile /E:/JavaCode/TestProj/out/production/TestProj/com/rhythm7/SayHelloKt.class
Last modified 2018-4-8; size 958 bytes
MD5 checksum 780a04b75a91be7605cac4655b499f19
Compiled from "SayHello.kt"
public final class com.rhythm7.SayHelloKt
minor version: 0
major version: 52
flags: ACC_PUBLIC, ACC_FINAL, ACC_SUPER
Constant pool://省略常量池部分字节码{
public static final void sayHello(java.lang.Object);
descriptor: (Ljava/lang/Object;)V
flags: ACC_PUBLIC, ACC_STATIC, ACC_FINAL
Code:
stack=2, locals=2, args_size=1
0: aload_0
1: ldc #9 // String $receiver
3: invokestatic #15 // Method kotlin/jvm/internal/Intrinsics.checkParameterIsNotNull:(Ljava/lang/Object;Ljava/lang/String;)V
6: ldc #17 // String Hello
8: astore_1
9: getstatic #23 // Field java/lang/System.out:Ljava/io/PrintStream;
12: aload_1
13: invokevirtual #28 // Method java/io/PrintStream.println:(Ljava/lang/Object;)V
16: return
LocalVariableTable:
Start Length Slot Name Signature
0 17 0 $receiver Ljava/lang/Object;
LineNumberTable:
line 4: 6
line 5: 16
RuntimeInvisibleParameterAnnotations:
0:
0: #7()
}
SourceFile: "SayHello.kt"

观察头部发现,koltin为文件SayHello生成了一个类，类名"com.rhythm7.SayHelloKt". 由于我们一开始编写SayHello.kt时并不希望
SayHello是一个可实例化的对象类，所以，SayHelloKt是无法被实例化的，SayHelloKt并没有任何一个构造器。 再观察唯一的一个方法：发现Any.sayHello() 的具体实现是静态不可变方法的形式:

public static final void sayHello(java.lang.Object);

所以当我们在其他地方使用Any.sayHello() 时，事实上等同于调用java的SayHelloKt.sayHello(Object) 方法。 顺便一提的是，当扩展的方法为Any时，意味着Any是non-null的，这时，编译器会在方法体的开头检查参数的非空，即调用kotlin.jvm.internal.Intrinsics.checkParameterIsNotNull(Object value, String paramName) 方法来检查传入的Any类型对象是否为空。如果我们扩展的函数为Any?.sayHello() ，那么在编译后的文件中则不会有这段字节码的出现。
--------------------- 
作者：哎呦、不错哦 
来源：CSDN 
原文：https://blog.csdn.net/l1394049664/article/details/81489960 
版权声明：本文为博主原创文章，转载请附上博文链接！