Java字节码解读

柔光的暖阳◎ 2023-03-04 15:23 34阅读 0赞

### 文章目录 ###

*   *  1. 字节码
     *  2. 字节码结构
     *   *  2.1 魔数
         *  2.2 版本号
         *  2.3 常量池
         *   *  2.3.1 常量池容量计数器
             *  2.3.2 常量解读
         *  2.4 访问标志
         *  2.5 类索引,父类索引,接口索引
         *   *  2.5.1 类索引
             *  2.5.2 父类索引
             *  2.5.3 接口计数器
             *  2.5.4 接口索引集合
         *  2.6 字段表
         *   *  2.6.1 字段表计数器
             *  2.6.2 字段表 单个分析
         *  2.7 方法表
         *   *  2.7.1 方法表的结构
             *  2.7.2 方法表访问标志
             *  2.7.3 解读方法
         *  2.8 属性表
         *   *  2.8.1 属性类型
             *  2.8.2 属性表结构
             *  2.8.3 Code属性
         *  2.9 附加属性
         *  2.10 其他属性
     *  3. 总结
     *  4. 参考:

## 1. 字节码 ##

Java字节码是Java虚拟机执行的一种指令格式.class文件是编译器编译之后供虚拟机解释执行的二进制字节码文件.

下面举个例子,写一段Java打码,并编译.

package com.xfhy.test;
    
    public class Hello { 
        private int num = 1;
    
        public int add() { 
            num = num + 2;
            return num;
        }
    }

编译得到class文件之后,用Hex Fiend软件打开该class文件.

CAFEBABE 00000034 00130A00 04000F09 00030010 07001107 00120100 036E756D
    01000149 0100063C 696E6974 3E010003 28295601 0004436F 64650100 0F4C696E
    654E756D 62657254 61626C65 01000361 64640100 03282949 01000A53 6F757263
    6546696C 6501000A 48656C6C 6F2E6A61 76610C00 0700080C 00050006 01001363
    6F6D2F78 6668792F 74657374 2F48656C 6C6F0100 106A6176 612F6C61 6E672F4F
    626A6563 74002100 03000400 00000100 02000500 06000000 02000100 07000800
    01000900 00002600 02000100 00000A2A B700012A 04B50002 B1000000 01000A00
    00000A00 02000000 03000400 04000100 0B000C00 01000900 00002B00 03000100
    00000F2A 2AB40002 0560B500 022AB400 02AC0000 0001000A 0000000A 00020000
    0007000A 00080001 000D0000 0002000E

class文件内部就是长这个样子. 里面是一堆16进制字节,完全看不懂.JVM是如何解读的?

## 2. 字节码结构 ##

class文件格式采用一种类似于C语言结构体的伪结构来存储数据,这种伪结构只有两种数据类型: 无符号数和表.

*  无符号数: 无符号数可以用来描述数字、索引引用、数量值或按照utf-8编码构成的字符串值.其中无符号数属于基本的数据类型。  
    以u1、u2、u4、u8来分别代表1个字节、2个字节、4个字节和8个字节.
 *  表: 表是由多个无符号数或其他表构成的复合数据结构.所有的表都以“\_info”结尾,  
    由于表没有固定长度,所以通常会在其前面加上个数说明.

class的内容其实就是下面这张表里面的数据顺序排列的,只需要安装这个顺序逐一进行解读就可以了:

<table> 
 <thead> 
  <tr> 
   <th>类型</th> 
   <th>名称</th> 
   <th>说明</th> 
   <th>长度</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>u4</td> 
   <td>magic</td> 
   <td>魔数，识别 Class 文件格式</td> 
   <td>4 个字节</td> 
  </tr> 
  <tr> 
   <td>u2</td> 
   <td>minor_version</td> 
   <td>副版本号</td> 
   <td>2 个字节</td> 
  </tr> 
  <tr> 
   <td>u2</td> 
   <td>major_version</td> 
   <td>主版本号</td> 
   <td>2 个字节</td> 
  </tr> 
  <tr> 
   <td>u2</td> 
   <td>constant_pool_count</td> 
   <td>常量池计算器</td> 
   <td>2 个字节</td> 
  </tr> 
  <tr> 
   <td>cp_info</td> 
   <td>constant_pool</td> 
   <td>常量池</td> 
   <td>n 个字节</td> 
  </tr> 
  <tr> 
   <td>u2</td> 
   <td>access_flags</td> 
   <td>访问标志</td> 
   <td>2 个字节</td> 
  </tr> 
  <tr> 
   <td>u2</td> 
   <td>this_class</td> 
   <td>类索引</td> 
   <td>2 个字节</td> 
  </tr> 
  <tr> 
   <td>u2</td> 
   <td>super_class</td> 
   <td>父类索引</td> 
   <td>2 个字节</td> 
  </tr> 
  <tr> 
   <td>u2</td> 
   <td>interfaces_count</td> 
   <td>接口计数器</td> 
   <td>2 个字节</td> 
  </tr> 
  <tr> 
   <td>u2</td> 
   <td>interfaces</td> 
   <td>接口索引集合</td> 
   <td>2 个字节</td> 
  </tr> 
  <tr> 
   <td>u2</td> 
   <td>fields_count</td> 
   <td>字段个数</td> 
   <td>2 个字节</td> 
  </tr> 
  <tr> 
   <td>field_info</td> 
   <td>fields</td> 
   <td>字段集合</td> 
   <td>n 个字节</td> 
  </tr> 
  <tr> 
   <td>u2</td> 
   <td>methods_count</td> 
   <td>方法计数器</td> 
   <td>2 个字节</td> 
  </tr> 
  <tr> 
   <td>method_info</td> 
   <td>methods</td> 
   <td>方法集合</td> 
   <td>n 个字节</td> 
  </tr> 
  <tr> 
   <td>u2</td> 
   <td>attributes_count</td> 
   <td>附加属性计数器</td> 
   <td>2 个字节</td> 
  </tr> 
  <tr> 
   <td>attribute_info</td> 
   <td>attributes</td> 
   <td>附加属性集合</td> 
   <td>n 个字节</td> 
  </tr> 
 </tbody> 
</table>

### 2.1 魔数 ###

用于标记当前文件是class(为啥不是用后缀来标记该文件为class文件,因为防止后缀被修改,为了安全),固定值为0XCAFEBABE.文件一开始就是这个.

### 2.2 版本号 ###

魔数后面的`00000034`是版本号,也是4个字节，其中前2个字节表示副版本号，后2个字节表示主版本号.这里0034对应的值是52,也就是`jdk 1.8.0`

### 2.3 常量池 ###

#### 2.3.1 常量池容量计数器 ####

接着是常量池相关的东西了,常量池的数量不固定,需要2个字节来表示常量池容量计数值.demo里面是`0013`,也就是19.

咱通过`javap -verbose Hello`命令查看该class的字节码如下(只截取了常量池部分数据):

Constant pool:
       #1 = Methodref          #4.#15         // java/lang/Object."<init>":()V
       #2 = Fieldref           #3.#16         // com/xfhy/test/Hello.num:I
       #3 = Class              #17            // com/xfhy/test/Hello
       #4 = Class              #18            // java/lang/Object
       #5 = Utf8               num
       #6 = Utf8               I
       #7 = Utf8               <init>
       #8 = Utf8               ()V
       #9 = Utf8               Code
      #10 = Utf8               LineNumberTable
      #11 = Utf8               add
      #12 = Utf8               ()I
      #13 = Utf8               SourceFile
      #14 = Utf8               Hello.java
      #15 = NameAndType        #7:#8          // "<init>":()V
      #16 = NameAndType        #5:#6          // num:I
      #17 = Utf8               com/xfhy/test/Hello
      #18 = Utf8               java/lang/Object

可以看到这里其实序号是从1开始的,而且总共是18个??? 那为啥class文件里面的数值是19?因为它把第0项常量空出来了:这是为了在于满足后面某些指向常量池的索引值的数据在特定情况下需要表达"不引用任何一个常量池项目"的含义,这种情况可用索引值0来表示.

#### 2.3.2 常量解读 ####

首先是第一个常量`0x0a`,即10.这里的10代表的是`CONSTANT_Methodref_info`,即类中方法的符号引用. 常量标志数值的含义表:

<table> 
 <thead> 
  <tr> 
   <th>类型</th> 
   <th>标志</th> 
   <th>描述</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>CONSTANT_utf8_info</td> 
   <td>1</td> 
   <td>UTF-8 编码的字符串</td> 
  </tr> 
  <tr> 
   <td>CONSTANT_Integer_info</td> 
   <td>3</td> 
   <td>整形字面量</td> 
  </tr> 
  <tr> 
   <td>CONSTANT_Float_info</td> 
   <td>4</td> 
   <td>浮点型字面量</td> 
  </tr> 
  <tr> 
   <td>CONSTANT_Long_info</td> 
   <td>5</td> 
   <td>长整型字面量</td> 
  </tr> 
  <tr> 
   <td>CONSTANT_Double_info</td> 
   <td>6</td> 
   <td>双精度浮点型字面量</td> 
  </tr> 
  <tr> 
   <td>CONSTANT_Class_info</td> 
   <td>7</td> 
   <td>类或接口的符号引用</td> 
  </tr> 
  <tr> 
   <td>CONSTANT_String_info</td> 
   <td>8</td> 
   <td>字符串类型字面量</td> 
  </tr> 
  <tr> 
   <td>CONSTANT_Fieldref_info</td> 
   <td>9</td> 
   <td>字段的符号引用</td> 
  </tr> 
  <tr> 
   <td>CONSTANT_Methodref_info</td> 
   <td>10</td> 
   <td>类中方法的符号引用</td> 
  </tr> 
  <tr> 
   <td>CONSTANT_InterfaceMethodref_info</td> 
   <td>11</td> 
   <td>接口中方法的符号引用</td> 
  </tr> 
  <tr> 
   <td>CONSTANT_NameAndType_info</td> 
   <td>12</td> 
   <td>字段或方法的符号引用</td> 
  </tr> 
  <tr> 
   <td>CONSTANT_MethodHandle_info</td> 
   <td>15</td> 
   <td>表示方法句柄</td> 
  </tr> 
  <tr> 
   <td>CONSTANT_MothodType_info</td> 
   <td>16</td> 
   <td>标志方法类型</td> 
  </tr> 
  <tr> 
   <td>CONSTANT_InvokeDynamic_info</td> 
   <td>18</td> 
   <td>表示一个动态方法调用点</td> 
  </tr> 
 </tbody> 
</table>

什么是符号引用? 常量池主要存放两大常量,`字面量`和`符号引用`.

*  字面量: 文本字符串,声明为final的常量值
 *  符号引用: 类和接口的全限定名,字段的名称和描述符,方法的名称和描述符

知道了该标志的含义,说明接下来的数据就是类中方法的符号引用的数据.但是我们不知道这个数据到底有多长.得看下面这个表格,常量池中的17种数据类型的结构总表,才知道它的结构到底如何:

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3hmaHlf_size_16_color_FFFFFF_t_70]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3hmaHlf_size_16_color_FFFFFF_t_70 1]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3hmaHlf_size_16_color_FFFFFF_t_70 2]

从表中查出`CONSTANT_Methodref_info`的tag是10,上面已经拿到了.然后接下来的2个u2表示它的数据,在demo中的值为: `0004 000F`

*  前两位的值为`0x0004`,即 4,指向常量池第 4 项的索引
 *  后两位的值为`0x000f`,即 15,指向常量池第 15 项的索引

至此,第一个常量就解读完毕了.后面还有17个常量,就不一一解读了,就是查字典.所有的常量都在这里了,它们最后的解读出来是和`javap -verbose Hello`解读出来的`Constant pool`是一致的.

0A00 04000F09 00030010 07001107 00120100 036E756D
    01000149 0100063C 696E6974 3E010003 28295601 0004436F 64650100 0F4C696E
    654E756D 62657254 61626C65 01000361 64640100 03282949 01000A53 6F757263
    6546696C 6501000A 48656C6C 6F2E6A61 76610C00 0700080C 00050006 01001363
    6F6D2F78 6668792F 74657374 2F48656C 6C6F0100 106A6176 612F6C61 6E672F4F
    626A6563 74

### 2.4 访问标志 ###

常量池过了就是访问标志了,用两个字节来表示，其标识了类或者接口的访问信息，比如：该 Class 文件是类还是接口，是否被定义成`public`，是否是`abstract`，如果是类，是否被声明成`final`等等。各种访问标志如下所示:

<table> 
 <thead> 
  <tr> 
   <th>标志名称</th> 
   <th>标志值</th> 
   <th>含义</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>ACC_PUBLIC</td> 
   <td>0x0001</td> 
   <td>是否为 Public 类型</td> 
  </tr> 
  <tr> 
   <td>ACC_FINAL</td> 
   <td>0x0010</td> 
   <td>是否被声明为 final，只有类可以设置</td> 
  </tr> 
  <tr> 
   <td>ACC_SUPER</td> 
   <td>0x0020</td> 
   <td>是否允许使用 invokespecial 字节码指令的新语义，JDK1.0.2 之后编译出来的类的这个标志默认为真</td> 
  </tr> 
  <tr> 
   <td>ACC_INTERFACE</td> 
   <td>0x0200</td> 
   <td>标志这是一个接口</td> 
  </tr> 
  <tr> 
   <td>ACC_ABSTRACT</td> 
   <td>0x0400</td> 
   <td>是否为 abstract 类型，对于接口或者抽象类来说，次标志值为真，其他类型为假</td> 
  </tr> 
  <tr> 
   <td>ACC_SYNTHETIC</td> 
   <td>0x1000</td> 
   <td>标志这个类并非由用户代码产生</td> 
  </tr> 
  <tr> 
   <td>ACC_ANNOTATION</td> 
   <td>0x2000</td> 
   <td>标志这是一个注解</td> 
  </tr> 
  <tr> 
   <td>ACC_ENUM</td> 
   <td>x4000</td> 
   <td>标志这是一个枚举</td> 
  </tr> 
 </tbody> 
</table>

在本demo中是`0021`,为了方便寻找,我加了`~~`将该位置数据间隔开.

CAFEBABE 00000034 00130A00 04000F09 00030010 07001107 00120100 036E756D
    01000149 0100063C 696E6974 3E010003 28295601 0004436F 64650100 0F4C696E
    654E756D 62657254 61626C65 01000361 64640100 03282949 01000A53 6F757263
    6546696C 6501000A 48656C6C 6F2E6A61 76610C00 0700080C 00050006 01001363
    6F6D2F78 6668792F 74657374 2F48656C 6C6F0100 106A6176 612F6C61 6E672F4F
    626A6563 74~~0021~~00 03000400 00000100 02000500 06000000 02000100 07000800
    01000900 00002600 02000100 00000A2A B700012A 04B50002 B1000000 01000A00
    00000A00 02000000 03000400 04000100 0B000C00 01000900 00002B00 03000100
    00000F2A 2AB40002 0560B500 022AB400 02AC0000 0001000A 0000000A 00020000
    0007000A 00080001 000D0000 0002000E

`0x0021`就是`0x0001`和`0x0020`的并集,即就是public.

### 2.5 类索引,父类索引,接口索引 ###

*  访问标志后的两个字节就是类索引
 *  类索引后的两个字节就是父类索引
 *  父类索引后的两个字节则是接口索引计数器

我将数据标记了一下:

CAFEBABE 00000034 00130A00 04000F09 00030010 07001107 00120100 036E756D
    01000149 0100063C 696E6974 3E010003 28295601 0004436F 64650100 0F4C696E
    654E756D 62657254 61626C65 01000361 64640100 03282949 01000A53 6F757263
    6546696C 6501000A 48656C6C 6F2E6A61 76610C00 0700080C 00050006 01001363
    6F6D2F78 6668792F 74657374 2F48656C 6C6F0100 106A6176 612F6C61 6E672F4F
    626A6563 740021~~00 03000400 00~~000100 02000500 06000000 02000100 07000800
    01000900 00002600 02000100 00000A2A B700012A 04B50002 B1000000 01000A00
    00000A00 02000000 03000400 04000100 0B000C00 01000900 00002B00 03000100
    00000F2A 2AB40002 0560B500 022AB400 02AC0000 0001000A 0000000A 00020000
    0007000A 00080001 000D0000 0002000E

#### 2.5.1 类索引 ####

类索引的值为`0x0003`, 即为指向常量池中第三项的索引`com/xfhy/test/Hello`,这里用到了常量池,通过类索引可以确定类的全限定名.

#### 2.5.2 父类索引 ####

父类索引的值为`0x0004`,即为指向常量池中第4项的索引`java/lang/Object`,类都是继承自Object的.

#### 2.5.3 接口计数器 ####

然后是接口计数器`0x0000`,这里没有接口,所以是0.

#### 2.5.4 接口索引集合 ####

这里本来接下来是接口索引集合的,但是这里没有用,所以不占数据空间.

### 2.6 字段表 ###

字段表用来描述类或者接口中声明的变量.这里的字段包含了类级别变量以及实例变量,但是不包括方法内部声明的局部变量.

字段表里面包含了以下几个数据:

<table> 
 <thead> 
  <tr> 
   <th>类型</th> 
   <th>名称</th> 
   <th>含义</th> 
   <th>数量</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>u2</td> 
   <td>access_flags</td> 
   <td>访问标志</td> 
   <td>1</td> 
  </tr> 
  <tr> 
   <td>u2</td> 
   <td>name_index</td> 
   <td>字段名索引</td> 
   <td>1</td> 
  </tr> 
  <tr> 
   <td>u2</td> 
   <td>descriptor_index</td> 
   <td>描述符索引</td> 
   <td>1</td> 
  </tr> 
  <tr> 
   <td>u2</td> 
   <td>attributes_count</td> 
   <td>属性计数器</td> 
   <td>1</td> 
  </tr> 
  <tr> 
   <td>attribute_info</td> 
   <td>attributes</td> 
   <td>属性集合</td> 
   <td>attributes_count</td> 
  </tr> 
 </tbody> 
</table>

我将数据标记了一下:

CAFEBABE 00000034 00130A00 04000F09 00030010 07001107 00120100 036E756D
    01000149 0100063C 696E6974 3E010003 28295601 0004436F 64650100 0F4C696E
    654E756D 62657254 61626C65 01000361 64640100 03282949 01000A53 6F757263
    6546696C 6501000A 48656C6C 6F2E6A61 76610C00 0700080C 00050006 01001363
    6F6D2F78 6668792F 74657374 2F48656C 6C6F0100 106A6176 612F6C61 6E672F4F
    626A6563 74002100 03000400 00~~000100 02000500 060000~~00 02000100 07000800
    01000900 00002600 02000100 00000A2A B700012A 04B50002 B1000000 01000A00
    00000A00 02000000 03000400 04000100 0B000C00 01000900 00002B00 03000100
    00000F2A 2AB40002 0560B500 022AB400 02AC0000 0001000A 0000000A 00020000
    0007000A 00080001 000D0000 0002000E

#### 2.6.1 字段表计数器 ####

值为`0x0001`,因为只有一个字段.

#### 2.6.2 字段表 单个分析 ####

接下来将demo中的这个字段进行分析一下,首先是字段表访问标志,这里的值是`0x0002`,是什么含义呢?得看下面这张表

<table> 
 <thead> 
  <tr> 
   <th>标志名称</th> 
   <th>标志值</th> 
   <th>含义</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>ACC_PUBLIC</td> 
   <td>0x0001</td> 
   <td>字段是否为 public</td> 
  </tr> 
  <tr> 
   <td>ACC_PRIVATE</td> 
   <td>0x0002</td> 
   <td>字段是否为 private</td> 
  </tr> 
  <tr> 
   <td>ACC_PROTECTED</td> 
   <td>0x0004</td> 
   <td>字段是否为 protected</td> 
  </tr> 
  <tr> 
   <td>ACC_STATIC</td> 
   <td>0x0008</td> 
   <td>字段是否为 static</td> 
  </tr> 
  <tr> 
   <td>ACC_FINAL</td> 
   <td>0x0010</td> 
   <td>字段是否为 final</td> 
  </tr> 
  <tr> 
   <td>ACC_VOLATILE</td> 
   <td>0x0040</td> 
   <td>字段是否为 volatile</td> 
  </tr> 
  <tr> 
   <td>ACC_TRANSTENT</td> 
   <td>0x0080</td> 
   <td>字段是否为 transient</td> 
  </tr> 
  <tr> 
   <td>ACC_SYNCHETIC</td> 
   <td>0x1000</td> 
   <td>字段是否为由编译器自动产生</td> 
  </tr> 
  <tr> 
   <td>ACC_ENUM</td> 
   <td>0x4000</td> 
   <td>字段是否为 enum</td> 
  </tr> 
 </tbody> 
</table>

值是`0x0002`代表着private修饰符.

*  访问标志的值为`0x0002`，查询上面字段访问标志的表格，可得字段为`private`；
 *  字段名索引的值为`0x0005`, 查询常量池中的第 5 项, 可得: `num`
 *  描述符索引的值为`0x0006`, 查询常量池中的第 6 项, 可得: `I`
 *  属性计数器的值为`0x0000`, 即没有任何的属性.

### 2.7 方法表 ###

接下来是方法表,前面两个字节依然用来表示方法表的容量,我将数据标记了一下:

CAFEBABE 00000034 00130A00 04000F09 00030010 07001107 00120100 036E756D
    01000149 0100063C 696E6974 3E010003 28295601 0004436F 64650100 0F4C696E
    654E756D 62657254 61626C65 01000361 64640100 03282949 01000A53 6F757263
    6546696C 6501000A 48656C6C 6F2E6A61 76610C00 0700080C 00050006 01001363
    6F6D2F78 6668792F 74657374 2F48656C 6C6F0100 106A6176 612F6C61 6E672F4F
    626A6563 74002100 03000400 00000100 02000500 060000~~00 02000100 07000800
    010009~~00 00002600 02000100 00000A2A B700012A 04B50002 B1000000 01000A00
    00000A00 02000000 03000400 04000100 0B000C00 01000900 00002B00 03000100
    00000F2A 2AB40002 0560B500 022AB400 02AC0000 0001000A 0000000A 00020000
    0007000A 00080001 000D0000 0002000E

方法表的容量为`0x0002`,即demo中有2个方法(还有1个默认的构造方法,别忘了…).

#### 2.7.1 方法表的结构 ####

既然是表,那肯定有结构,还有严格的顺序规定.

<table> 
 <thead> 
  <tr> 
   <th>类型</th> 
   <th>名称</th> 
   <th>含义</th> 
   <th>数量</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>u2</td> 
   <td>access_flags</td> 
   <td>访问标志</td> 
   <td>1</td> 
  </tr> 
  <tr> 
   <td>u2</td> 
   <td>name_index</td> 
   <td>方法名索引</td> 
   <td>1</td> 
  </tr> 
  <tr> 
   <td>u2</td> 
   <td>descriptor_index</td> 
   <td>描述符索引</td> 
   <td>1</td> 
  </tr> 
  <tr> 
   <td>u2</td> 
   <td>attributes_count</td> 
   <td>属性计数器</td> 
   <td>1</td> 
  </tr> 
  <tr> 
   <td>attribute_info</td> 
   <td>attributes</td> 
   <td>属性集合</td> 
   <td>attributes_count</td> 
  </tr> 
 </tbody> 
</table>

#### 2.7.2 方法表访问标志 ####

方法也是有访问标志的

<table> 
 <thead> 
  <tr> 
   <th>标志名称</th> 
   <th>标志值</th> 
   <th>含义</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>ACC_PUBLIC</td> 
   <td>0x0001</td> 
   <td>方法是否为 public</td> 
  </tr> 
  <tr> 
   <td>ACC_PRIVATE</td> 
   <td>0x0002</td> 
   <td>方法是否为 private</td> 
  </tr> 
  <tr> 
   <td>ACC_PROTECTED</td> 
   <td>0x0004</td> 
   <td>方法是否为 protected</td> 
  </tr> 
  <tr> 
   <td>ACC_STATIC</td> 
   <td>0x0008</td> 
   <td>方法是否为 static</td> 
  </tr> 
  <tr> 
   <td>ACC_FINAL</td> 
   <td>0x0010</td> 
   <td>方法是否为 final</td> 
  </tr> 
  <tr> 
   <td>ACC_SYHCHRONRIZED</td> 
   <td>0x0020</td> 
   <td>方法是否为 synchronized</td> 
  </tr> 
  <tr> 
   <td>ACC_BRIDGE</td> 
   <td>0x0040</td> 
   <td>方法是否是有编译器产生的方法</td> 
  </tr> 
  <tr> 
   <td>ACC_VARARGS</td> 
   <td>0x0080</td> 
   <td>方法是否接受参数</td> 
  </tr> 
  <tr> 
   <td>ACC_NATIVE</td> 
   <td>0x0100</td> 
   <td>方法是否为 native</td> 
  </tr> 
  <tr> 
   <td>ACC_ABSTRACT</td> 
   <td>0x0400</td> 
   <td>方法是否为 abstract</td> 
  </tr> 
  <tr> 
   <td>ACC_STRICTFP</td> 
   <td>0x0800</td> 
   <td>方法是否为 strictfp</td> 
  </tr> 
  <tr> 
   <td>ACC_SYNTHETIC</td> 
   <td>0x1000</td> 
   <td>方法是否是有编译器自动产生的</td> 
  </tr> 
 </tbody> 
</table>

#### 2.7.3 解读方法 ####

第一个方法是:

000100 07000800 010009

*  访问标志的值为`0x0001`，查询上面字段访问标志的表格，可得字段为 public；
 *  方法名索引的值为`0x0007`，查询常量池中的第 7 项，可得：`<init>`
 *  这个名为`<init>`的方法实际上就是`默认的构造方法`了。
 *  描述符索引的值为`0x0008`，查询常量池中的第 8 项，可得：`()V`
 *  属性计数器的值为`0x0001`，即这个方法表有一个属性。
 *  属性计数器后面就是属性表了，由于只有一个属性，所以这里也只有一个属性表。  
    由于涉及到属性表，这里简单说下，下一节会详细介绍。  
    属性表的前两个字节是属性名称索引，这里的值为`0x0009`, 查下常量池中的第 9 项:`Code`.即这是一个`Code`属性，我们方法里面的代码就是存放在这个 Code 属性里面。相关细节暂且不表。下一节会详细介绍 Code 属性。

先跳过属性表，我们再来看下第二个方法: `000100 0B000C00 010009`

*  访问标志的值为`0x0001`，查询上面字段访问标志的表格，可得字段为 public；
 *  方法名索引的值为`0x000b`，查询常量池中的第 11 项，可得: `add`
 *  描述符索引的值为 `0x000c`，查询常量池中的第 12 项，可得: `()I`
 *  属性计数器的值为`0x0001`，即这个方法表有一个属性。
 *  属性名称索引的值同样也是`0x0009`，即这是一个 Code 属性。 可以看到，第二个方法表就是我们自定义的`add()`方法了。

### 2.8 属性表 ###

上面提到了属性表,现在我们来看一下属性表是什么.

#### 2.8.1 属性类型 ####

属性表实际上有很多类型,上面看到的Code属性只是其中一个.

<table> 
 <thead> 
  <tr> 
   <th>属性名称</th> 
   <th>使用位置</th> 
   <th>含义</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>Code</td> 
   <td>方法表</td> 
   <td>Java 代码编译成的字节码指令</td> 
  </tr> 
  <tr> 
   <td>ConstantValue</td> 
   <td>字段表</td> 
   <td>final 关键字定义的常量池</td> 
  </tr> 
  <tr> 
   <td>Deprecated</td> 
   <td>类，方法，字段表</td> 
   <td>被声明为 deprecated 的方法和字段</td> 
  </tr> 
  <tr> 
   <td>Exceptions</td> 
   <td>方法表</td> 
   <td>方法抛出的异常</td> 
  </tr> 
  <tr> 
   <td>EnclosingMethod</td> 
   <td>类文件</td> 
   <td>仅当一个类为局部类或者匿名类是才能拥有这个属性，这个属性用于标识这个类所在的外围方法</td> 
  </tr> 
  <tr> 
   <td>InnerClass</td> 
   <td>类文件</td> 
   <td>内部类列表</td> 
  </tr> 
  <tr> 
   <td>LineNumberTable</td> 
   <td>Code 属性</td> 
   <td>Java 源码的行号与字节码指令的对应关系</td> 
  </tr> 
  <tr> 
   <td>LocalVariableTable</td> 
   <td>Code 属性</td> 
   <td>方法的局部便狼描述</td> 
  </tr> 
  <tr> 
   <td>StackMapTable</td> 
   <td>Code 属性</td> 
   <td>JDK1.6 中新增的属性，供新的类型检查检验器检查和处理目标方法的局部变量和操作数有所需要的类是否匹配</td> 
  </tr> 
  <tr> 
   <td>Signature</td> 
   <td>类，方法表，字段表</td> 
   <td>用于支持泛型情况下的方法签名</td> 
  </tr> 
  <tr> 
   <td>SourceFile</td> 
   <td>类文件</td> 
   <td>记录源文件名称</td> 
  </tr> 
  <tr> 
   <td>SourceDebugExtension</td> 
   <td>类文件</td> 
   <td>用于存储额外的调试信息</td> 
  </tr> 
  <tr> 
   <td>Synthetic</td> 
   <td>类，方法表，字段表</td> 
   <td>标志方法或字段为编译器自动生成的</td> 
  </tr> 
  <tr> 
   <td>LocalVariableTypeTable</td> 
   <td>类</td> 
   <td>使用特征签名代替描述符，是为了引入泛型语法之后能描述泛型参数化类型而添加</td> 
  </tr> 
  <tr> 
   <td>RuntimeVisibleAnnotations</td> 
   <td>类，方法表，字段表</td> 
   <td>为动态注解提供支持</td> 
  </tr> 
  <tr> 
   <td>RuntimeInvisibleAnnotations</td> 
   <td>表，方法表，字段表</td> 
   <td>用于指明哪些注解是运行时不可见的</td> 
  </tr> 
  <tr> 
   <td>RuntimeVisibleParameterAnnotation</td> 
   <td>方法表</td> 
   <td>作用与 RuntimeVisibleAnnotations 属性类似，只不过作用对象为方法</td> 
  </tr> 
  <tr> 
   <td>RuntimeInvisibleParameterAnnotation</td> 
   <td>方法表</td> 
   <td>作用与 RuntimeInvisibleAnnotations 属性类似，作用对象哪个为方法参数</td> 
  </tr> 
  <tr> 
   <td>AnnotationDefault</td> 
   <td>方法表</td> 
   <td>用于记录注解类元素的默认值</td> 
  </tr> 
  <tr> 
   <td>BootstrapMethods</td> 
   <td>类文件</td> 
   <td>用于保存 invokeddynamic 指令引用的引导方式限定符</td> 
  </tr> 
 </tbody> 
</table>

#### 2.8.2 属性表结构 ####

知道了属性之后,还得知道该属性对应的结构,然后才能解析出来:

可以看到这里的属性表其实只是定义了属性的长度,里面还有一个表用来自定义的,是不定长的,具体的结构是自己去定义的.

#### 2.8.3 Code属性 ####

这里只单独介绍一下Code属性.Code属性就是存放方法体里面的代码,像接口或者抽象方法,它们没有具体的方法体,因此不会有Code属性.

Code属性表结构:

<table> 
 <thead> 
  <tr> 
   <th>类型</th> 
   <th>名称</th> 
   <th>数量</th> 
   <th>含义</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>u2</td> 
   <td>attribute_name_index</td> 
   <td>1</td> 
   <td>属性名索引</td> 
  </tr> 
  <tr> 
   <td>u4</td> 
   <td>attribute_length</td> 
   <td>1</td> 
   <td>属性长度</td> 
  </tr> 
  <tr> 
   <td>u2</td> 
   <td>max_stack</td> 
   <td>1</td> 
   <td>操作数栈深度的最大值</td> 
  </tr> 
  <tr> 
   <td>u2</td> 
   <td>max_locals</td> 
   <td>1</td> 
   <td>局部变量表所需的存续空间</td> 
  </tr> 
  <tr> 
   <td>u4</td> 
   <td>code_length</td> 
   <td>1</td> 
   <td>字节码指令的长度</td> 
  </tr> 
  <tr> 
   <td>u1</td> 
   <td>code</td> 
   <td>code_length</td> 
   <td>存储字节码指令</td> 
  </tr> 
  <tr> 
   <td>u2</td> 
   <td>exception_table_length</td> 
   <td>1</td> 
   <td>异常表长度</td> 
  </tr> 
  <tr> 
   <td>exception_info</td> 
   <td>exception_table</td> 
   <td>exception_length</td> 
   <td>异常表</td> 
  </tr> 
  <tr> 
   <td>u2</td> 
   <td>attributes_count</td> 
   <td>1</td> 
   <td>属性集合计数器</td> 
  </tr> 
  <tr> 
   <td>attribute_info</td> 
   <td>attributes</td> 
   <td>attributes_count</td> 
   <td>属性集合</td> 
  </tr> 
 </tbody> 
</table>

Code属性表的前两项是和属性表是一致的,Code属性是遵循属性表的结构,后面那些是它自定义的结构.

这里我就不再一一去解读Code属性了,就是查字典.

我们可以一步到位,使用`javap -verbose Hello`可以得到得到字节码指令

public com.xfhy.test.Hello();
        descriptor: ()V
        flags: ACC_PUBLIC
        Code:
          stack=2, locals=1, args_size=1
             0: aload_0
             1: invokespecial #1                  // Method java/lang/Object."<init>":()V
             4: aload_0
             5: iconst_1
             6: putfield      #2                  // Field num:I
             9: return
          LineNumberTable:
            line 3: 0
            line 4: 4
    
      public int add();
        descriptor: ()I
        flags: ACC_PUBLIC
        Code:
          stack=3, locals=1, args_size=1
             0: aload_0
             1: aload_0
             2: getfield      #2                  // Field num:I
             5: iconst_2
             6: iadd
             7: putfield      #2                  // Field num:I
            10: aload_0
            11: getfield      #2                  // Field num:I
            14: ireturn
          LineNumberTable:
            line 7: 0
            line 8: 10

这里涉及到一些字节码指令,这些指令含义如下表:

<table> 
 <thead> 
  <tr> 
   <th>字节码</th> 
   <th>助记符</th> 
   <th>指令含义</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>0x00</td> 
   <td>nop</td> 
   <td>什么都不做</td> 
  </tr> 
  <tr> 
   <td>0x01</td> 
   <td>aconst_null</td> 
   <td>将 null 推送至栈顶</td> 
  </tr> 
  <tr> 
   <td>0x02</td> 
   <td>iconst_m1</td> 
   <td>将 int 型 - 1 推送至栈顶</td> 
  </tr> 
  <tr> 
   <td>0x03</td> 
   <td>iconst_0</td> 
   <td>将 int 型 0 推送至栈顶</td> 
  </tr> 
  <tr> 
   <td>0x04</td> 
   <td>iconst_1</td> 
   <td>将 int 型 1 推送至栈顶</td> 
  </tr> 
  <tr> 
   <td>0x05</td> 
   <td>iconst_2</td> 
   <td>将 int 型 2 推送至栈顶</td> 
  </tr> 
  <tr> 
   <td>0x06</td> 
   <td>iconst_3</td> 
   <td>将 int 型 3 推送至栈顶</td> 
  </tr> 
  <tr> 
   <td>0x07</td> 
   <td>iconst_4</td> 
   <td>将 int 型 4 推送至栈顶</td> 
  </tr> 
  <tr> 
   <td>0x08</td> 
   <td>iconst_5</td> 
   <td>将 int 型 5 推送至栈顶</td> 
  </tr> 
  <tr> 
   <td>0x09</td> 
   <td>lconst_0</td> 
   <td>将 long 型 0 推送至栈顶</td> 
  </tr> 
  <tr> 
   <td>0x0a</td> 
   <td>lconst_1</td> 
   <td>将 long 型 1 推送至栈顶</td> 
  </tr> 
  <tr> 
   <td>0x0b</td> 
   <td>fconst_0</td> 
   <td>将 float 型 0 推送至栈顶</td> 
  </tr> 
  <tr> 
   <td>0x0c</td> 
   <td>fconst_1</td> 
   <td>将 float 型 1 推送至栈顶</td> 
  </tr> 
  <tr> 
   <td>0x0d</td> 
   <td>fconst_2</td> 
   <td>将 float 型 2 推送至栈顶</td> 
  </tr> 
  <tr> 
   <td>0x0e</td> 
   <td>dconst_0</td> 
   <td>将 do le 型 0 推送至栈顶</td> 
  </tr> 
  <tr> 
   <td>0x0f</td> 
   <td>dconst_1</td> 
   <td>将 do le 型 1 推送至栈顶</td> 
  </tr> 
  <tr> 
   <td>0x10</td> 
   <td>bipush</td> 
   <td>将单字节的常量值 (-128~127) 推送至栈顶</td> 
  </tr> 
  <tr> 
   <td>0x11</td> 
   <td>sipush</td> 
   <td>将一个短整型常量值 (-32768~32767) 推送至栈顶</td> 
  </tr> 
  <tr> 
   <td>0x12</td> 
   <td>ldc</td> 
   <td>将 int, float 或 String 型常量值从常量池中推送至栈顶</td> 
  </tr> 
  <tr> 
   <td>0x13</td> 
   <td>ldc_w</td> 
   <td>将 int, float 或 String 型常量值从常量池中推送至栈顶（宽索引）</td> 
  </tr> 
  <tr> 
   <td>0x14</td> 
   <td>ldc2_w</td> 
   <td>将 long 或 do le 型常量值从常量池中推送至栈顶（宽索引）</td> 
  </tr> 
  <tr> 
   <td>0x15</td> 
   <td>iload</td> 
   <td>将指定的 int 型本地变量</td> 
  </tr> 
  <tr> 
   <td>0x16</td> 
   <td>lload</td> 
   <td>将指定的 long 型本地变量</td> 
  </tr> 
  <tr> 
   <td>0x17</td> 
   <td>fload</td> 
   <td>将指定的 float 型本地变量</td> 
  </tr> 
  <tr> 
   <td>0x18</td> 
   <td>dload</td> 
   <td>将指定的 do le 型本地变量</td> 
  </tr> 
  <tr> 
   <td>0x19</td> 
   <td>aload</td> 
   <td>将指定的引用类型本地变量</td> 
  </tr> 
  <tr> 
   <td>0x1a</td> 
   <td>iload_0</td> 
   <td>将第一个 int 型本地变量</td> 
  </tr> 
  <tr> 
   <td>0x1b</td> 
   <td>iload_1</td> 
   <td>将第二个 int 型本地变量</td> 
  </tr> 
  <tr> 
   <td>0x1c</td> 
   <td>iload_2</td> 
   <td>将第三个 int 型本地变量</td> 
  </tr> 
  <tr> 
   <td>0x1d</td> 
   <td>iload_3</td> 
   <td>将第四个 int 型本地变量</td> 
  </tr> 
  <tr> 
   <td>0x1e</td> 
   <td>lload_0</td> 
   <td>将第一个 long 型本地变量</td> 
  </tr> 
  <tr> 
   <td>0x1f</td> 
   <td>lload_1</td> 
   <td>将第二个 long 型本地变量</td> 
  </tr> 
  <tr> 
   <td>0x20</td> 
   <td>lload_2</td> 
   <td>将第三个 long 型本地变量</td> 
  </tr> 
  <tr> 
   <td>0x21</td> 
   <td>lload_3</td> 
   <td>将第四个 long 型本地变量</td> 
  </tr> 
  <tr> 
   <td>0x22</td> 
   <td>fload_0</td> 
   <td>将第一个 float 型本地变量</td> 
  </tr> 
  <tr> 
   <td>0x23</td> 
   <td>fload_1</td> 
   <td>将第二个 float 型本地变量</td> 
  </tr> 
  <tr> 
   <td>0x24</td> 
   <td>fload_2</td> 
   <td>将第三个 float 型本地变量</td> 
  </tr> 
  <tr> 
   <td>0x25</td> 
   <td>fload_3</td> 
   <td>将第四个 float 型本地变量</td> 
  </tr> 
  <tr> 
   <td>0x26</td> 
   <td>dload_0</td> 
   <td>将第一个 do le 型本地变量</td> 
  </tr> 
  <tr> 
   <td>0x27</td> 
   <td>dload_1</td> 
   <td>将第二个 do le 型本地变量</td> 
  </tr> 
  <tr> 
   <td>0x28</td> 
   <td>dload_2</td> 
   <td>将第三个 do le 型本地变量</td> 
  </tr> 
  <tr> 
   <td>0x29</td> 
   <td>dload_3</td> 
   <td>将第四个 do le 型本地变量</td> 
  </tr> 
  <tr> 
   <td>0x2a</td> 
   <td>aload_0</td> 
   <td>将第一个引用类型本地变量</td> 
  </tr> 
  <tr> 
   <td>0x2b</td> 
   <td>aload_1</td> 
   <td>将第二个引用类型本地变量</td> 
  </tr> 
  <tr> 
   <td>0x2c</td> 
   <td>aload_2</td> 
   <td>将第三个引用类型本地变量</td> 
  </tr> 
  <tr> 
   <td>0x2d</td> 
   <td>aload_3</td> 
   <td>将第四个引用类型本地变量</td> 
  </tr> 
  <tr> 
   <td>0x2e</td> 
   <td>iaload</td> 
   <td>将 int 型数组指定索引的值推送至栈顶</td> 
  </tr> 
  <tr> 
   <td>0x2f</td> 
   <td>laload</td> 
   <td>将 long 型数组指定索引的值推送至栈顶</td> 
  </tr> 
  <tr> 
   <td>0x30</td> 
   <td>faload</td> 
   <td>将 float 型数组指定索引的值推送至栈顶</td> 
  </tr> 
  <tr> 
   <td>0x31</td> 
   <td>daload</td> 
   <td>将 do le 型数组指定索引的值推送至栈顶</td> 
  </tr> 
  <tr> 
   <td>0x32</td> 
   <td>aaload</td> 
   <td>将引用型数组指定索引的值推送至栈顶</td> 
  </tr> 
  <tr> 
   <td>0x33</td> 
   <td>baload</td> 
   <td>将 boolean 或 byte 型数组指定索引的值推送至栈顶</td> 
  </tr> 
  <tr> 
   <td>0x34</td> 
   <td>caload</td> 
   <td>将 char 型数组指定索引的值推送至栈顶</td> 
  </tr> 
  <tr> 
   <td>0x35</td> 
   <td>saload</td> 
   <td>将 short 型数组指定索引的值推送至栈顶</td> 
  </tr> 
  <tr> 
   <td>0x36</td> 
   <td>istore</td> 
   <td>将栈顶 int 型数值存入指定本地变量</td> 
  </tr> 
  <tr> 
   <td>0x37</td> 
   <td>lstore</td> 
   <td>将栈顶 long 型数值存入指定本地变量</td> 
  </tr> 
  <tr> 
   <td>0x38</td> 
   <td>fstore</td> 
   <td>将栈顶 float 型数值存入指定本地变量</td> 
  </tr> 
  <tr> 
   <td>0x39</td> 
   <td>dstore</td> 
   <td>将栈顶 do le 型数值存入指定本地变量</td> 
  </tr> 
  <tr> 
   <td>0x3a</td> 
   <td>astore</td> 
   <td>将栈顶引用型数值存入指定本地变量</td> 
  </tr> 
  <tr> 
   <td>0x3b</td> 
   <td>istore_0</td> 
   <td>将栈顶 int 型数值存入第一个本地变量</td> 
  </tr> 
  <tr> 
   <td>0x3c</td> 
   <td>istore_1</td> 
   <td>将栈顶 int 型数值存入第二个本地变量</td> 
  </tr> 
  <tr> 
   <td>0x3d</td> 
   <td>istore_2</td> 
   <td>将栈顶 int 型数值存入第三个本地变量</td> 
  </tr> 
  <tr> 
   <td>0x3e</td> 
   <td>istore_3</td> 
   <td>将栈顶 int 型数值存入第四个本地变量</td> 
  </tr> 
  <tr> 
   <td>0x3f</td> 
   <td>lstore_0</td> 
   <td>将栈顶 long 型数值存入第一个本地变量</td> 
  </tr> 
  <tr> 
   <td>0x40</td> 
   <td>lstore_1</td> 
   <td>将栈顶 long 型数值存入第二个本地变量</td> 
  </tr> 
  <tr> 
   <td>0x41</td> 
   <td>lstore_2</td> 
   <td>将栈顶 long 型数值存入第三个本地变量</td> 
  </tr> 
  <tr> 
   <td>0x42</td> 
   <td>lstore_3</td> 
   <td>将栈顶 long 型数值存入第四个本地变量</td> 
  </tr> 
  <tr> 
   <td>0x43</td> 
   <td>fstore_0</td> 
   <td>将栈顶 float 型数值存入第一个本地变量</td> 
  </tr> 
  <tr> 
   <td>0x44</td> 
   <td>fstore_1</td> 
   <td>将栈顶 float 型数值存入第二个本地变量</td> 
  </tr> 
  <tr> 
   <td>0x45</td> 
   <td>fstore_2</td> 
   <td>将栈顶 float 型数值存入第三个本地变量</td> 
  </tr> 
  <tr> 
   <td>0x46</td> 
   <td>fstore_3</td> 
   <td>将栈顶 float 型数值存入第四个本地变量</td> 
  </tr> 
  <tr> 
   <td>0x47</td> 
   <td>dstore_0</td> 
   <td>将栈顶 do le 型数值存入第一个本地变量</td> 
  </tr> 
  <tr> 
   <td>0x48</td> 
   <td>dstore_1</td> 
   <td>将栈顶 do le 型数值存入第二个本地变量</td> 
  </tr> 
  <tr> 
   <td>0x49</td> 
   <td>dstore_2</td> 
   <td>将栈顶 do le 型数值存入第三个本地变量</td> 
  </tr> 
  <tr> 
   <td>0x4a</td> 
   <td>dstore_3</td> 
   <td>将栈顶 do le 型数值存入第四个本地变量</td> 
  </tr> 
  <tr> 
   <td>0x4b</td> 
   <td>astore_0</td> 
   <td>将栈顶引用型数值存入第一个本地变量</td> 
  </tr> 
  <tr> 
   <td>0x4c</td> 
   <td>astore_1</td> 
   <td>将栈顶引用型数值存入第二个本地变量</td> 
  </tr> 
  <tr> 
   <td>0x4d</td> 
   <td>astore_2</td> 
   <td>将栈顶引用型数值存入第三个本地变量</td> 
  </tr> 
  <tr> 
   <td>0x4e</td> 
   <td>astore_3</td> 
   <td>将栈顶引用型数值存入第四个本地变量</td> 
  </tr> 
  <tr> 
   <td>0x4f</td> 
   <td>iastore</td> 
   <td>将栈顶 int 型数值存入指定数组的指定索引位置</td> 
  </tr> 
  <tr> 
   <td>0x50</td> 
   <td>lastore</td> 
   <td>将栈顶 long 型数值存入指定数组的指定索引位置</td> 
  </tr> 
  <tr> 
   <td>0x51</td> 
   <td>fastore</td> 
   <td>将栈顶 float 型数值存入指定数组的指定索引位置</td> 
  </tr> 
  <tr> 
   <td>0x52</td> 
   <td>dastore</td> 
   <td>将栈顶 do le 型数值存入指定数组的指定索引位置</td> 
  </tr> 
  <tr> 
   <td>0x53</td> 
   <td>aastore</td> 
   <td>将栈顶引用型数值存入指定数组的指定索引位置</td> 
  </tr> 
  <tr> 
   <td>0x54</td> 
   <td>bastore</td> 
   <td>将栈顶 boolean 或 byte 型数值存入指定数组的指定索引位置</td> 
  </tr> 
  <tr> 
   <td>0x55</td> 
   <td>castore</td> 
   <td>将栈顶 char 型数值存入指定数组的指定索引位置</td> 
  </tr> 
  <tr> 
   <td>0x56</td> 
   <td>sastore</td> 
   <td>将栈顶 short 型数值存入指定数组的指定索引位置</td> 
  </tr> 
  <tr> 
   <td>0x57</td> 
   <td>pop</td> 
   <td>将栈顶数值弹出 (数值不能是 long 或 do le 类型的)</td> 
  </tr> 
  <tr> 
   <td>0x58</td> 
   <td>pop2</td> 
   <td>将栈顶的一个（long 或 do le 类型的) 或两个数值弹出（其它）</td> 
  </tr> 
  <tr> 
   <td>0x59</td> 
   <td>dup</td> 
   <td>复制栈顶数值并将复制值压入栈顶</td> 
  </tr> 
  <tr> 
   <td>0x5a</td> 
   <td>dup_x1</td> 
   <td>复制栈顶数值并将两个复制值压入栈顶</td> 
  </tr> 
  <tr> 
   <td>0x5b</td> 
   <td>dup_x2</td> 
   <td>复制栈顶数值并将三个（或两个）复制值压入栈顶</td> 
  </tr> 
  <tr> 
   <td>0x5c</td> 
   <td>dup2</td> 
   <td>复制栈顶一个（long 或 do le 类型的) 或两个（其它）数值并将复制值压入栈顶</td> 
  </tr> 
  <tr> 
   <td>0x5d</td> 
   <td>dup2_x1</td> 
   <td>dup_x1 指令的双倍版本</td> 
  </tr> 
  <tr> 
   <td>0x5e</td> 
   <td>dup2_x2</td> 
   <td>dup_x2 指令的双倍版本</td> 
  </tr> 
  <tr> 
   <td>0x5f</td> 
   <td>swap</td> 
   <td>将栈最顶端的两个数值互换 (数值不能是 long 或 do le 类型的)</td> 
  </tr> 
  <tr> 
   <td>0x60</td> 
   <td>iadd</td> 
   <td>将栈顶两 int 型数值相加并将结果压入栈顶</td> 
  </tr> 
  <tr> 
   <td>0x61</td> 
   <td>ladd</td> 
   <td>将栈顶两 long 型数值相加并将结果压入栈顶</td> 
  </tr> 
  <tr> 
   <td>0x62</td> 
   <td>fadd</td> 
   <td>将栈顶两 float 型数值相加并将结果压入栈顶</td> 
  </tr> 
  <tr> 
   <td>0x63</td> 
   <td>dadd</td> 
   <td>将栈顶两 do le 型数值相加并将结果压入栈顶</td> 
  </tr> 
  <tr> 
   <td>0x64</td> 
   <td>is</td> 
   <td>将栈顶两 int 型数值相减并将结果压入栈顶</td> 
  </tr> 
  <tr> 
   <td>0x65</td> 
   <td>ls</td> 
   <td>将栈顶两 long 型数值相减并将结果压入栈顶</td> 
  </tr> 
  <tr> 
   <td>0x66</td> 
   <td>fs</td> 
   <td>将栈顶两 float 型数值相减并将结果压入栈顶</td> 
  </tr> 
  <tr> 
   <td>0x67</td> 
   <td>ds</td> 
   <td>将栈顶两 do le 型数值相减并将结果压入栈顶</td> 
  </tr> 
  <tr> 
   <td>0x68</td> 
   <td>imul</td> 
   <td>将栈顶两 int 型数值相乘并将结果压入栈顶</td> 
  </tr> 
  <tr> 
   <td>0x69</td> 
   <td>lmul</td> 
   <td>将栈顶两 long 型数值相乘并将结果压入栈顶</td> 
  </tr> 
  <tr> 
   <td>0x6a</td> 
   <td>fmul</td> 
   <td>将栈顶两 float 型数值相乘并将结果压入栈顶</td> 
  </tr> 
  <tr> 
   <td>0x6b</td> 
   <td>dmul</td> 
   <td>将栈顶两 do le 型数值相乘并将结果压入栈顶</td> 
  </tr> 
  <tr> 
   <td>0x6c</td> 
   <td>idiv</td> 
   <td>将栈顶两 int 型数值相除并将结果压入栈顶</td> 
  </tr> 
  <tr> 
   <td>0x6d</td> 
   <td>ldiv</td> 
   <td>将栈顶两 long 型数值相除并将结果压入栈顶</td> 
  </tr> 
  <tr> 
   <td>0x6e</td> 
   <td>fdiv</td> 
   <td>将栈顶两 float 型数值相除并将结果压入栈顶</td> 
  </tr> 
  <tr> 
   <td>0x6f</td> 
   <td>ddiv</td> 
   <td>将栈顶两 do le 型数值相除并将结果压入栈顶</td> 
  </tr> 
  <tr> 
   <td>0x70</td> 
   <td>irem</td> 
   <td>将栈顶两 int 型数值作取模运算并将结果压入栈顶</td> 
  </tr> 
  <tr> 
   <td>0x71</td> 
   <td>lrem</td> 
   <td>将栈顶两 long 型数值作取模运算并将结果压入栈顶</td> 
  </tr> 
  <tr> 
   <td>0x72</td> 
   <td>frem</td> 
   <td>将栈顶两 float 型数值作取模运算并将结果压入栈顶</td> 
  </tr> 
  <tr> 
   <td>0x73</td> 
   <td>drem</td> 
   <td>将栈顶两 do le 型数值作取模运算并将结果压入栈顶</td> 
  </tr> 
  <tr> 
   <td>0x74</td> 
   <td>ineg</td> 
   <td>将栈顶 int 型数值取负并将结果压入栈顶</td> 
  </tr> 
  <tr> 
   <td>0x75</td> 
   <td>lneg</td> 
   <td>将栈顶 long 型数值取负并将结果压入栈顶</td> 
  </tr> 
  <tr> 
   <td>0x76</td> 
   <td>fneg</td> 
   <td>将栈顶 float 型数值取负并将结果压入栈顶</td> 
  </tr> 
  <tr> 
   <td>0x77</td> 
   <td>dneg</td> 
   <td>将栈顶 do le 型数值取负并将结果压入栈顶</td> 
  </tr> 
  <tr> 
   <td>0x78</td> 
   <td>ishl</td> 
   <td>将 int 型数值左移位指定位数并将结果压入栈顶</td> 
  </tr> 
  <tr> 
   <td>0x79</td> 
   <td>lshl</td> 
   <td>将 long 型数值左移位指定位数并将结果压入栈顶</td> 
  </tr> 
  <tr> 
   <td>0x7a</td> 
   <td>ishr</td> 
   <td>将 int 型数值右（符号）移位指定位数并将结果压入栈顶</td> 
  </tr> 
  <tr> 
   <td>0x7b</td> 
   <td>lshr</td> 
   <td>将 long 型数值右（符号）移位指定位数并将结果压入栈顶</td> 
  </tr> 
  <tr> 
   <td>0x7c</td> 
   <td>iushr</td> 
   <td>将 int 型数值右（无符号）移位指定位数并将结果压入栈顶</td> 
  </tr> 
  <tr> 
   <td>0x7d</td> 
   <td>lushr</td> 
   <td>将 long 型数值右（无符号）移位指定位数并将结果压入栈顶</td> 
  </tr> 
  <tr> 
   <td>0x7e</td> 
   <td>iand</td> 
   <td>将栈顶两 int 型数值作 “按位与” 并将结果压入栈顶</td> 
  </tr> 
  <tr> 
   <td>0x7f</td> 
   <td>land</td> 
   <td>将栈顶两 long 型数值作 “按位与” 并将结果压入栈顶</td> 
  </tr> 
  <tr> 
   <td>0x80</td> 
   <td>ior</td> 
   <td>将栈顶两 int 型数值作 “按位或” 并将结果压入栈顶</td> 
  </tr> 
  <tr> 
   <td>0x81</td> 
   <td>lor</td> 
   <td>将栈顶两 long 型数值作 “按位或” 并将结果压入栈顶</td> 
  </tr> 
  <tr> 
   <td>0x82</td> 
   <td>ixor</td> 
   <td>将栈顶两 int 型数值作 “按位异或” 并将结果压入栈顶</td> 
  </tr> 
  <tr> 
   <td>0x83</td> 
   <td>lxor</td> 
   <td>将栈顶两 long 型数值作 “按位异或” 并将结果压入栈顶</td> 
  </tr> 
  <tr> 
   <td>0x84</td> 
   <td>iinc</td> 
   <td>将指定 int 型变量增加指定值（i++, i–, i+=2）</td> 
  </tr> 
  <tr> 
   <td>0x85</td> 
   <td>i2l</td> 
   <td>将栈顶 int 型数值强制转换成 long 型数值并将结果压入栈顶</td> 
  </tr> 
  <tr> 
   <td>0x86</td> 
   <td>i2f</td> 
   <td>将栈顶 int 型数值强制转换成 float 型数值并将结果压入栈顶</td> 
  </tr> 
  <tr> 
   <td>0x87</td> 
   <td>i2d</td> 
   <td>将栈顶 int 型数值强制转换成 do le 型数值并将结果压入栈顶</td> 
  </tr> 
  <tr> 
   <td>0x88</td> 
   <td>l2i</td> 
   <td>将栈顶 long 型数值强制转换成 int 型数值并将结果压入栈顶</td> 
  </tr> 
  <tr> 
   <td>0x89</td> 
   <td>l2f</td> 
   <td>将栈顶 long 型数值强制转换成 float 型数值并将结果压入栈顶</td> 
  </tr> 
  <tr> 
   <td>0x8a</td> 
   <td>l2d</td> 
   <td>将栈顶 long 型数值强制转换成 do le 型数值并将结果压入栈顶</td> 
  </tr> 
  <tr> 
   <td>0x8b</td> 
   <td>f2i</td> 
   <td>将栈顶 float 型数值强制转换成 int 型数值并将结果压入栈顶</td> 
  </tr> 
  <tr> 
   <td>0x8c</td> 
   <td>f2l</td> 
   <td>将栈顶 float 型数值强制转换成 long 型数值并将结果压入栈顶</td> 
  </tr> 
  <tr> 
   <td>0x8d</td> 
   <td>f2d</td> 
   <td>将栈顶 float 型数值强制转换成 do le 型数值并将结果压入栈顶</td> 
  </tr> 
  <tr> 
   <td>0x8e</td> 
   <td>d2i</td> 
   <td>将栈顶 do le 型数值强制转换成 int 型数值并将结果压入栈顶</td> 
  </tr> 
  <tr> 
   <td>0x8f</td> 
   <td>d2l</td> 
   <td>将栈顶 do le 型数值强制转换成 long 型数值并将结果压入栈顶</td> 
  </tr> 
  <tr> 
   <td>0x90</td> 
   <td>d2f</td> 
   <td>将栈顶 do le 型数值强制转换成 float 型数值并将结果压入栈顶</td> 
  </tr> 
  <tr> 
   <td>0x91</td> 
   <td>i2b</td> 
   <td>将栈顶 int 型数值强制转换成 byte 型数值并将结果压入栈顶</td> 
  </tr> 
  <tr> 
   <td>0x92</td> 
   <td>i2c</td> 
   <td>将栈顶 int 型数值强制转换成 char 型数值并将结果压入栈顶</td> 
  </tr> 
  <tr> 
   <td>0x93</td> 
   <td>i2s</td> 
   <td>将栈顶 int 型数值强制转换成 short 型数值并将结果压入栈顶</td> 
  </tr> 
  <tr> 
   <td>0x94</td> 
   <td>lcmp</td> 
   <td>比较栈顶两 long 型数值大小，并将结果（1，0，-1）压入栈顶</td> 
  </tr> 
  <tr> 
   <td>0x95</td> 
   <td>fcmpl</td> 
   <td>比较栈顶两 float 型数值大小，并将结果（1，0，-1）压入栈顶；当其中一个数值为 NaN 时，将 - 1 压入栈顶</td> 
  </tr> 
  <tr> 
   <td>0x96</td> 
   <td>fcmpg</td> 
   <td>比较栈顶两 float 型数值大小，并将结果（1，0，-1）压入栈顶；当其中一个数值为 NaN 时，将 1 压入栈顶</td> 
  </tr> 
  <tr> 
   <td>0x97</td> 
   <td>dcmpl</td> 
   <td>比较栈顶两 do le 型数值大小，并将结果（1，0，-1）压入栈顶；当其中一个数值为 NaN 时，将 - 1 压入栈顶</td> 
  </tr> 
  <tr> 
   <td>0x98</td> 
   <td>dcmpg</td> 
   <td>比较栈顶两 do le 型数值大小，并将结果（1，0，-1）压入栈顶；当其中一个数值为 NaN 时，将 1 压入栈顶</td> 
  </tr> 
  <tr> 
   <td>0x99</td> 
   <td>ifeq</td> 
   <td>当栈顶 int 型数值等于 0 时跳转</td> 
  </tr> 
  <tr> 
   <td>0x9a</td> 
   <td>ifne</td> 
   <td>当栈顶 int 型数值不等于 0 时跳转</td> 
  </tr> 
  <tr> 
   <td>0x9b</td> 
   <td>iflt</td> 
   <td>当栈顶 int 型数值小于 0 时跳转</td> 
  </tr> 
  <tr> 
   <td>0x9c</td> 
   <td>ifge</td> 
   <td>当栈顶 int 型数值大于等于 0 时跳转</td> 
  </tr> 
  <tr> 
   <td>0x9d</td> 
   <td>ifgt</td> 
   <td>当栈顶 int 型数值大于 0 时跳转</td> 
  </tr> 
  <tr> 
   <td>0x9e</td> 
   <td>ifle</td> 
   <td>当栈顶 int 型数值小于等于 0 时跳转</td> 
  </tr> 
  <tr> 
   <td>0x9f</td> 
   <td>if_icmpeq</td> 
   <td>比较栈顶两 int 型数值大小，当结果等于 0 时跳转</td> 
  </tr> 
  <tr> 
   <td>0xa0</td> 
   <td>if_icmpne</td> 
   <td>比较栈顶两 int 型数值大小，当结果不等于 0 时跳转</td> 
  </tr> 
  <tr> 
   <td>0xa1</td> 
   <td>if_icmplt</td> 
   <td>比较栈顶两 int 型数值大小，当结果小于 0 时跳转</td> 
  </tr> 
  <tr> 
   <td>0xa2</td> 
   <td>if_icmpge</td> 
   <td>比较栈顶两 int 型数值大小，当结果大于等于 0 时跳转</td> 
  </tr> 
  <tr> 
   <td>0xa3</td> 
   <td>if_icmpgt</td> 
   <td>比较栈顶两 int 型数值大小，当结果大于 0 时跳转</td> 
  </tr> 
  <tr> 
   <td>0xa4</td> 
   <td>if_icmple</td> 
   <td>比较栈顶两 int 型数值大小，当结果小于等于 0 时跳转</td> 
  </tr> 
  <tr> 
   <td>0xa5</td> 
   <td>if_acmpeq</td> 
   <td>比较栈顶两引用型数值，当结果相等时跳转</td> 
  </tr> 
  <tr> 
   <td>0xa6</td> 
   <td>if_acmpne</td> 
   <td>比较栈顶两引用型数值，当结果不相等时跳转</td> 
  </tr> 
  <tr> 
   <td>0xa7</td> 
   <td>goto</td> 
   <td>无条件跳转</td> 
  </tr> 
  <tr> 
   <td>0xa8</td> 
   <td>jsr</td> 
   <td>跳转至指定 16 位 offset 位置，并将 jsr 下一条指令地址压入栈顶</td> 
  </tr> 
  <tr> 
   <td>0xa9</td> 
   <td>ret</td> 
   <td>返回至本地变量</td> 
  </tr> 
  <tr> 
   <td>0xaa</td> 
   <td>tableswitch</td> 
   <td>用于 switch 条件跳转，case 值连续（可变长度指令）</td> 
  </tr> 
  <tr> 
   <td>0xab</td> 
   <td>lookupswitch</td> 
   <td>用于 switch 条件跳转，case 值不连续（可变长度指令）</td> 
  </tr> 
  <tr> 
   <td>0xac</td> 
   <td>ireturn</td> 
   <td>从当前方法返回 int</td> 
  </tr> 
  <tr> 
   <td>0xad</td> 
   <td>lreturn</td> 
   <td>从当前方法返回 long</td> 
  </tr> 
  <tr> 
   <td>0xae</td> 
   <td>freturn</td> 
   <td>从当前方法返回 float</td> 
  </tr> 
  <tr> 
   <td>0xaf</td> 
   <td>dreturn</td> 
   <td>从当前方法返回 do le</td> 
  </tr> 
  <tr> 
   <td>0xb0</td> 
   <td>areturn</td> 
   <td>从当前方法返回对象引用</td> 
  </tr> 
  <tr> 
   <td>0xb1</td> 
   <td>return</td> 
   <td>从当前方法返回 void</td> 
  </tr> 
  <tr> 
   <td>0xb2</td> 
   <td>getstatic</td> 
   <td>获取指定类的静态域，并将其值压入栈顶</td> 
  </tr> 
  <tr> 
   <td>0xb3</td> 
   <td>putstatic</td> 
   <td>为指定的类的静态域赋值</td> 
  </tr> 
  <tr> 
   <td>0xb4</td> 
   <td>getfield</td> 
   <td>获取指定类的实例域，并将其值压入栈顶</td> 
  </tr> 
  <tr> 
   <td>0xb5</td> 
   <td>putfield</td> 
   <td>为指定的类的实例域赋值</td> 
  </tr> 
  <tr> 
   <td>0xb6</td> 
   <td>invokevirtual</td> 
   <td>调用实例方法</td> 
  </tr> 
  <tr> 
   <td>0xb7</td> 
   <td>invokespecial</td> 
   <td>调用超类构造方法，实例初始化方法，私有方法</td> 
  </tr> 
  <tr> 
   <td>0xb8</td> 
   <td>invokestatic</td> 
   <td>调用静态方法</td> 
  </tr> 
  <tr> 
   <td>0xb9</td> 
   <td>invokeinterface</td> 
   <td>调用接口方法</td> 
  </tr> 
  <tr> 
   <td>0xba</td> 
   <td>–</td> 
   <td>无此指令</td> 
  </tr> 
  <tr> 
   <td>0xbb</td> 
   <td>new</td> 
   <td>创建一个对象，并将其引用值压入栈顶</td> 
  </tr> 
  <tr> 
   <td>0xbc</td> 
   <td>newarray</td> 
   <td>创建一个指定原始类型（如 int, float, char…）的数组，并将其引用值压入栈顶</td> 
  </tr> 
  <tr> 
   <td>0xbd</td> 
   <td>anewarray</td> 
   <td>创建一个引用型（如类，接口，数组）的数组，并将其引用值压入栈顶</td> 
  </tr> 
  <tr> 
   <td>0xbe</td> 
   <td>arraylength</td> 
   <td>获得数组的长度值并压入栈顶</td> 
  </tr> 
  <tr> 
   <td>0xbf</td> 
   <td>athrow</td> 
   <td>将栈顶的异常抛出</td> 
  </tr> 
  <tr> 
   <td>0xc0</td> 
   <td>checkcast</td> 
   <td>检验类型转换，检验未通过将抛出 ClassCastException</td> 
  </tr> 
  <tr> 
   <td>0xc1</td> 
   <td>instanceof</td> 
   <td>检验对象是否是指定的类的实例，如果是将 1 压入栈顶，否则将 0 压入栈顶</td> 
  </tr> 
  <tr> 
   <td>0xc2</td> 
   <td>monitorenter</td> 
   <td>获得对象的锁，用于同步方法或同步块</td> 
  </tr> 
  <tr> 
   <td>0xc3</td> 
   <td>monitorexit</td> 
   <td>释放对象的锁，用于同步方法或同步块</td> 
  </tr> 
  <tr> 
   <td>0xc4</td> 
   <td>wide</td> 
   <td>&lt;待补充&gt;</td> 
  </tr> 
  <tr> 
   <td>0xc5</td> 
   <td>multianewarray</td> 
   <td>创建指定类型和指定维度的多维数组（执行该指令时，操作栈中必须包含各维度的长度值），并将其引用值压入栈顶</td> 
  </tr> 
  <tr> 
   <td>0xc6</td> 
   <td>ifnull</td> 
   <td>为 null 时跳转</td> 
  </tr> 
  <tr> 
   <td>0xc7</td> 
   <td>ifnonnull</td> 
   <td>不为 null 时跳转</td> 
  </tr> 
  <tr> 
   <td>0xc8</td> 
   <td>goto_w</td> 
   <td>无条件跳转（宽索引）</td> 
  </tr> 
  <tr> 
   <td>0xc9</td> 
   <td>jsr_w</td> 
   <td>跳转至指定 32 位 offset 位置，并将 jsr_w 下一条指令地址压入栈顶</td> 
  </tr> 
 </tbody> 
</table>

当然,这么多属性根本不用记住,需要的时候查表就行.

### 2.9 附加属性 ###

SourceFile 属性,即附加属性.它的属性结构如下

*  属性名索引的值为`0x000d`，即常量池中的第 13 项，查询可得: `SourceFile`
 *  属性长度的值为`0x00 00 00 02`, 即长度为 2
 *  源码文件索引的值为`0x000e`, 即常量池中的第 14 项, 查询可得: `Hello.java`

### 2.10 其他属性 ###

其他还有一些Java虚拟机预定义了很多属性,就不一一解读了,就是查字典.

## 3. 总结 ##

Java字节码就是一些Java虚拟机的指令,而这些指令需要依赖class文件,所以首先得读取class文件内容.而class文件内容就是一些16进制的数据,很紧凑地将数据按顺序摆放在一起,只需要顺序解读,即可得到指令内容.

> ps: 就像《深入理解Java虚拟机》一书中所说的那样,解读class其实就是查字典嘛,来嘛,查嘛,慢慢搞嘛,我就不行治不了你. 刚开始的时候读起来特别不舒服,读不太懂这玩意儿,后面慢慢地终于读懂了,再写篇文章详细记录一下,加深现象. 博客写得不是很详细,如果感兴趣,建议还是看书(《深入理解Java虚拟机》第六章)更系统些.

## 4. 参考: ##

*  [一文让你明白Java字节码][Java]
 *  [Java字节码 维基百科][Java_]
 *  [深入理解JVM 读懂java字节码][JVM _java]
 *  [如何阅读JAVA 字节码（一）][JAVA]
 *  [从一个class文件深入理解Java字节码结构][class_Java]
 *  《深入理解Java虚拟机》第六章

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3hmaHlf_size_16_color_FFFFFF_t_70]: /images/20230208/a7d12365dc894341ad41a2f07c6b7b11.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3hmaHlf_size_16_color_FFFFFF_t_70 1]: /images/20230208/dc0f0bb0f32642ee86b4a04abaae0e46.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3hmaHlf_size_16_color_FFFFFF_t_70 2]: /images/20230208/eda706c2eddf449e95fbe0c68b4aec4d.png
[Java]: https://www.jianshu.com/p/252f381a6bc4
[Java_]: https://zh.wikipedia.org/zh-hans/Java%E5%AD%97%E8%8A%82%E7%A0%81
[JVM _java]: https://www.jianshu.com/p/fa53b4169df9
[JAVA]: https://juejin.im/post/6844903464481325064
[class_Java]: https://www.jianshu.com/p/2c106b682cfb