Class文件结构分析

概述

在Java语言中，Java虚拟机只能理解字节码（class文件），它不面向任何处理器，不与任何语言绑定，只与Class文件这种特定的二进制文件格式所关联。

Java 语言通过字节码的方式，在一定程度上解决了传统解释型语言执行效率低的问题，同时又保留了解释型语言可移植的特点。所以 Java 程序运行时比较高效，而且，由于字节码并不针对一种特定的机器，因此，Java 程序无须重新编译便可在多种不同操作系统的计算机上运行。

另一方面由于JVM虚拟机不与任何语言、机器绑定，因而任何语言的实现着都可以将Java虚拟机作为语言的运行基础，以Class文件作为他们的交付媒介。例如Clojure（Lisp 语言的一种方言）、Groovy、JRuby等语言都是运行在 Java 虚拟机之上。

下图展示了不同的语言被不同的编译器编译成.class文件最终运行在 Java 虚拟机之上的过程：

Class文件的结构

根据《Java虚拟机规范》，Class 文件通过 ClassFile 定义，而且文件结构采用一种类似c语言结构体的伪结构体。这种伪结构体只有两种两种数据类型：“无符号数”和“表”。

• 无符号数：属于基本的数据结构，以u1、u2、u4、u8来分别代表1个字节、2个字节、4个字节、8个字节的无符号数。无符号数可以用来描述数字、索引引用、数字量值或者按照UTF-8编码构成字符串值
• 表：由多个无符号数或者其他表作为数据项构成的复合数据结构，为了便于区分，所有表的命名都习惯以 “_info” 结尾。

在正式开始讲，我们需要说明一点，Class文件的结构不像XML那样的结构化描述语言，它以8个字节为基础单位，各个数据项目严格按照顺序紧凑地排列在文件中，中间没有添加任何分隔符号，因而在Class的数据项无论是顺序还是数量，甚至数据存储的字节序（大端存储，Big-Endian）这样的细节，都是被严格限定的，哪个字节代表什么含义，长度是多少，先后顺序如何，全部都不允许改变。

ClassFile 的结构如下：

ClassFile {
    u4             magic; //Class 文件的标志
    u2             minor_version;//Class 的小版本号
    u2             major_version;//Class 的大版本号
    u2             constant_pool_count;//常量池的数量
    cp_info        constant_pool[constant_pool_count-1];//常量池
    u2             access_flags;//Class 的访问标记
    u2             this_class;//当前类
    u2             super_class;//父类
    u2             interfaces_count;//接口
    u2             interfaces[interfaces_count];//一个类可以实现多个接口
    u2             fields_count;//Class 文件的字段属性
    field_info     fields[fields_count];//一个类会可以有多个字段
    u2             methods_count;//Class 文件的方法数量
    method_info    methods[methods_count];//一个类可以有个多个方法
    u2             attributes_count;//此类的属性表中的属性数
    attribute_info attributes[attributes_count];//属性表集合
}

通过对ClassFile的分析，我们便可以知道class文件的组成。

上边的一些属性什么的，描述都很抽象，因而这里以一段典型的java代码产生的class文件为基础结合进行讲解。

一段典型的Java程序代码如下：

package com.test;

//接口类
interface Car {
    void drive();
}
//实现类
public class BMWCar implements Car{

    private String name;
  
    public BMWCar() {
        name = "宝马";
    }
  
    @Override
    public void drive() {
        System.out.println("BMW car drive." + name);
    }   
}

通过javac命令对代码进行编译，生成的class文件内容如下：

  Offset: 00 01 02 03 04 05 06 07 08 09 0A 0B 0C 0D 0E 0F 
00000000: CA FE BA BE 00 00 00 3B 00 33 07 00 02 01 00 0F    J~:>...;.3......
00000010: 63 6F 6D 2F 74 65 73 74 2F 42 4D 57 43 61 72 07    com/test/BMWCar.
00000020: 00 04 01 00 10 6A 61 76 61 2F 6C 61 6E 67 2F 4F    .....java/lang/O
00000030: 62 6A 65 63 74 07 00 06 01 00 0C 63 6F 6D 2F 74    bject......com/t
00000040: 65 73 74 2F 43 61 72 01 00 04 6E 61 6D 65 01 00    est/Car...name..
00000050: 12 4C 6A 61 76 61 2F 6C 61 6E 67 2F 53 74 72 69    .Ljava/lang/Stri
00000060: 6E 67 3B 01 00 06 3C 69 6E 69 74 3E 01 00 03 28    ng;...<init>...(
00000070: 29 56 01 00 04 43 6F 64 65 0A 00 03 00 0D 0C 00    )V...Code.......
00000080: 09 00 0A 08 00 0F 01 00 06 E5 AE 9D E9 A9 AC 09    .........e..i),.
00000090: 00 01 00 11 0C 00 07 00 08 01 00 0F 4C 69 6E 65    ............Line
000000a0: 4E 75 6D 62 65 72 54 61 62 6C 65 01 00 12 4C 6F    NumberTable...Lo
000000b0: 63 61 6C 56 61 72 69 61 62 6C 65 54 61 62 6C 65    calVariableTable
000000c0: 01 00 04 74 68 69 73 01 00 11 4C 63 6F 6D 2F 74    ...this...Lcom/t
000000d0: 65 73 74 2F 42 4D 57 43 61 72 3B 01 00 05 64 72    est/BMWCar;...dr
000000e0: 69 76 65 09 00 18 00 1A 07 00 19 01 00 10 6A 61    ive...........ja
000000f0: 76 61 2F 6C 61 6E 67 2F 53 79 73 74 65 6D 0C 00    va/lang/System..
00000100: 1B 00 1C 01 00 03 6F 75 74 01 00 15 4C 6A 61 76    ......out...Ljav
00000110: 61 2F 69 6F 2F 50 72 69 6E 74 53 74 72 65 61 6D    a/io/PrintStream
00000120: 3B 07 00 1E 01 00 17 6A 61 76 61 2F 6C 61 6E 67    ;......java/lang
00000130: 2F 53 74 72 69 6E 67 42 75 69 6C 64 65 72 08 00    /StringBuilder..
00000140: 20 01 00 0E 42 4D 57 20 63 61 72 20 64 72 69 76    ....BMW.car.driv
00000150: 65 2E 0A 00 1D 00 22 0C 00 09 00 23 01 00 15 28    e....."....#...(
00000160: 4C 6A 61 76 61 2F 6C 61 6E 67 2F 53 74 72 69 6E    Ljava/lang/Strin
00000170: 67 3B 29 56 0A 00 1D 00 25 0C 00 26 00 27 01 00    g;)V....%..&.'..
00000180: 06 61 70 70 65 6E 64 01 00 2D 28 4C 6A 61 76 61    .append..-(Ljava
00000190: 2F 6C 61 6E 67 2F 53 74 72 69 6E 67 3B 29 4C 6A    /lang/String;)Lj
000001a0: 61 76 61 2F 6C 61 6E 67 2F 53 74 72 69 6E 67 42    ava/lang/StringB
000001b0: 75 69 6C 64 65 72 3B 0A 00 1D 00 29 0C 00 2A 00    uilder;....)..*.
000001c0: 2B 01 00 08 74 6F 53 74 72 69 6E 67 01 00 14 28    +...toString...(
000001d0: 29 4C 6A 61 76 61 2F 6C 61 6E 67 2F 53 74 72 69    )Ljava/lang/Stri
000001e0: 6E 67 3B 0A 00 2D 00 2F 07 00 2E 01 00 13 6A 61    ng;..-./......ja
000001f0: 76 61 2F 69 6F 2F 50 72 69 6E 74 53 74 72 65 61    va/io/PrintStrea
00000200: 6D 0C 00 30 00 23 01 00 07 70 72 69 6E 74 6C 6E    m..0.#...println
00000210: 01 00 0A 53 6F 75 72 63 65 46 69 6C 65 01 00 0B    ...SourceFile...
00000220: 42 4D 57 43 61 72 2E 6A 61 76 61 00 21 00 01 00    BMWCar.java.!...
00000230: 03 00 01 00 05 00 01 00 02 00 07 00 08 00 00 00    ................
00000240: 02 00 01 00 09 00 0A 00 01 00 0B 00 00 00 3D 00    ..............=.
00000250: 02 00 01 00 00 00 0B 2A B7 00 0C 2A 12 0E B5 00    .......*7..*..5.
00000260: 10 B1 00 00 00 02 00 12 00 00 00 0E 00 03 00 00    .1..............
00000270: 00 0D 00 04 00 0E 00 0A 00 0F 00 13 00 00 00 0C    ................
00000280: 00 01 00 00 00 0B 00 14 00 15 00 00 00 01 00 16    ................
00000290: 00 0A 00 01 00 0B 00 00 00 48 00 04 00 01 00 00    .........H......
000002a0: 00 1A B2 00 17 BB 00 1D 59 12 1F B7 00 21 2A B4    ..2..;..Y..7.!*4
000002b0: 00 10 B6 00 24 B6 00 28 B6 00 2C B1 00 00 00 02    ..6.$6.(6.,1....
000002c0: 00 12 00 00 00 0A 00 02 00 00 00 13 00 19 00 14    ................
000002d0: 00 13 00 00 00 0C 00 01 00 00 00 1A 00 14 00 15    ................
000002e0: 00 00 00 01 00 31 00 00 00 02 00 32                .....1.....2

魔数

    u4             magic; //Class 文件的标志

每一个Class文件的头4个字节被称为魔数，它唯一的作用就是确定这个文件是否是一个能够被虚拟机接受的Class文件。

其在class文件中的具体位置如下图所示：

Clsss文件的魔数选的很有浪漫气息，值为0xCAFFEBABY（咖啡宝贝？）

Class 文件版本号（Minor&Major Version）

    u2             minor_version;//Class 的小版本号
    u2             major_version;//Class 的大版本号

紧跟着魔数的4个字节存储的是CLass文件的版本号：第5和第6个字节是次版本号（Minor Version），第7和8个字节存储的是主版本号（Manjor Version）。

每当 Java 发布大版本（比如 Java 8，Java9）的时候，主版本号都会加 1。你可以使用 javap -v 命令来快速查看 Class 文件的版本号信息。

高版本的 Java 虚拟机可以执行低版本编译器生成的 Class 文件，但是低版本的 Java 虚拟机不能执行高版本编译器生成的 Class 文件。 所以，我们在实际开发的时候要确保开发的的 JDK 版本和生产环境的 JDK 版本保持一致。

class版本号具体位置如下图所示:

从图中可以看到，我们class文件的主版本号是0x003B，也就是十进制的59，这个版本说明是可以被JDK15及 其以上版本的虚拟机运行。

常量池（Constant Pool）

    u2             constant_pool_count;//常量池的数量
    cp_info        constant_pool[constant_pool_count-1];//常量池

紧接着主、次版本号之后的是常量池的入口，常量池的数量为constant_pool_count - 1（常量池计数器是从 1 开始计数的，将第 0 项常量空出来是有特殊考虑的，索引值为 0 代表“不引用任何一个常量池项”）。

常量池中主要存放两大类常量：

• 字面量：比较接近于Java语言层面的常量概念，如文本字符串、被声明的final

“符号引用” ：属于编译原理方面的概念，主要包括三类常量：

• 类和接口的全限定名
• 字段的名称和描述符
• 方法的名称和描述符

常量池中，每一项常量都是一个表，截止到JDK13，常量表中共有17种不同类型的常量，它们有一个共同的特点即表结构起始的第一位是一个u1类型的标志位(tag)，代表当前常量属于哪种常量。

17中常量及其所对应的标志位如下表所示：

类型	标志（tag）	描述
CONSTANT_utf8_info	1	UTF-8 编码的字符串
CONSTANT_Integer_info	3	整形字面量
CONSTANT_Float_info	4	浮点型字面量
CONSTANT_Long_info	５	长整型字面量
CONSTANT_Double_info	６	双精度浮点型字面量
CONSTANT_Class_info	７	类或接口的符号引用
CONSTANT_String_info	８	字符串类型字面量
CONSTANT_Fieldref_info	９	字段的符号引用
CONSTANT_Methodref_info	10	类中方法的符号引用
CONSTANT_InterfaceMethodref_info	11	接口中方法的符号引用
CONSTANT_NameAndType_info	12	字段或方法的符号引用
CONSTANT_MothodType_info	16	标志方法类型
CONSTANT_MethodHandle_info	15	表示方法句柄
CONSTANT_InvokeDynamic_info	18	表示一个动态方法调用点

结合前边的Class文件：

可以看到常量池中常量的数量为0x33即有50个常量（因为从1开始计数），通过javap -v BMWCar命令可以查看Class文件的信息如下:

Classfile /C:/Users/vcjmhg/Desktop/test/com/test/BMWCar.class
  Last modified 2021-4-17; size 748 bytes
  MD5 checksum e3bb3d3eaf56cc12d92423d7b99781d2
  Compiled from "BMWCar.java"
public class com.test.BMWCar implements com.test.Car
  minor version: 0
  major version: 59
  flags: ACC_PUBLIC, ACC_SUPER
Constant pool:
   #1 = Class              #2             // com/test/BMWCar
   #2 = Utf8               com/test/BMWCar
   #3 = Class              #4             // java/lang/Object
   #4 = Utf8               java/lang/Object
   #5 = Class              #6             // com/test/Car
   #6 = Utf8               com/test/Car
   #7 = Utf8               name
   #8 = Utf8               Ljava/lang/String;
   #9 = Utf8               <init>
  #10 = Utf8               ()V
  #11 = Utf8               Code
  #12 = Methodref          #3.#13         // java/lang/Object."<init>":()V
  #13 = NameAndType        #9:#10         // "<init>":()V
  #14 = String             #15  
  #15 = Utf8   
  #16 = Fieldref           #1.#17         // com/test/BMWCar.name:Ljava/lang/String;
  #17 = NameAndType        #7:#8          // name:Ljava/lang/String;
  #18 = Utf8               LineNumberTable
  #19 = Utf8               LocalVariableTable
  #20 = Utf8               this
  #21 = Utf8               Lcom/test/BMWCar;
  #22 = Utf8               drive
  #23 = Fieldref           #24.#26        // java/lang/System.out:Ljava/io/PrintStream;
  #24 = Class              #25            // java/lang/System
  #25 = Utf8               java/lang/System
  #26 = NameAndType        #27:#28        // out:Ljava/io/PrintStream;
  #27 = Utf8               out
  #28 = Utf8               Ljava/io/PrintStream;
  #29 = Class              #30            // java/lang/StringBuilder
  #30 = Utf8               java/lang/StringBuilder
  #31 = String             #32            // BMW car drive.
  #32 = Utf8               BMW car drive.
  #33 = Methodref          #29.#34        // java/lang/StringBuilder."<init>":(Ljava/lang/String;)V
  #34 = NameAndType        #9:#35         // "<init>":(Ljava/lang/String;)V
  #35 = Utf8               (Ljava/lang/String;)V
  #36 = Methodref          #29.#37        // java/lang/StringBuilder.append:(Ljava/lang/String;)Ljava/lang/StringBuilder;
  #37 = NameAndType        #38:#39        // append:(Ljava/lang/String;)Ljava/lang/StringBuilder;
  #38 = Utf8               append
  #39 = Utf8               (Ljava/lang/String;)Ljava/lang/StringBuilder;
  #40 = Methodref          #29.#41        // java/lang/StringBuilder.toString:()Ljava/lang/String;
  #41 = NameAndType        #42:#43        // toString:()Ljava/lang/String;
  #42 = Utf8               toString
  #43 = Utf8               ()Ljava/lang/String;
  #44 = Methodref          #45.#47        // java/io/PrintStream.println:(Ljava/lang/String;)V
  #45 = Class              #46            // java/io/PrintStream
  #46 = Utf8               java/io/PrintStream
  #47 = NameAndType        #48:#35        // println:(Ljava/lang/String;)V
  #48 = Utf8               println
  #49 = Utf8               SourceFile
  #50 = Utf8               BMWCar.java
{
  public com.test.BMWCar();
    descriptor: ()V
    flags: ACC_PUBLIC
    Code:
      stack=2, locals=1, args_size=1
         0: aload_0
         1: invokespecial #12                 // Method java/lang/Object."<init>":()V
         4: aload_0
         5: ldc           #14                 // String 
         7: putfield      #16                 // Field name:Ljava/lang/String;
        10: return
      LineNumberTable:
        line 13: 0
        line 14: 4
        line 15: 10
      LocalVariableTable:
        Start  Length  Slot  Name   Signature
            0      11     0  this   Lcom/test/BMWCar;

  public void drive();
    descriptor: ()V
    flags: ACC_PUBLIC
    Code:
      stack=4, locals=1, args_size=1
         0: getstatic     #23                 // Field java/lang/System.out:Ljava/io/PrintStream;
         3: new           #29                 // class java/lang/StringBuilder
         6: dup
         7: ldc           #31                 // String BMW car drive.
         9: invokespecial #33                 // Method java/lang/StringBuilder."<init>":(Ljava/lang/String;)V
        12: aload_0
        13: getfield      #16                 // Field name:Ljava/lang/String;
        16: invokevirtual #36                 // Method java/lang/StringBuilder.append:(Ljava/lang/String;)Ljava/lang/StringBuilder;
        19: invokevirtual #40                 // Method java/lang/StringBuilder.toString:()Ljava/lang/String;
        22: invokevirtual #44                 // Method java/io/PrintStream.println:(Ljava/lang/String;)V
        25: return
      LineNumberTable:
        line 19: 0
        line 20: 25
      LocalVariableTable:
        Start  Length  Slot  Name   Signature
            0      26     0  this   Lcom/test/BMWCar;
}
SourceFile: "BMWCar.java"

首先我们尝试对第一个常量进行解析，首先找到它对应的标志位（表的第一个字节）为7，查询上边的常量表可知，该常量为一个CONSTANT_CLASSS_info（类或者接口的符号引用）

查询CONSTANT_class_info的结构如下：

类型	名称	数量
u1	tag	标志位
u2	name_index	1

tag位前边我们说了，它是所有表的一个共同特征，用来指明表的类型；

name_index是常量池的索引值，指向常量池中一个CONSTANT_Utf8_info类型常量，代表这个类的全限定名。

由于第一个常量的name_index = 2，也就是指向了常量池中的第二个常量。

首先可以看到它的tag=1，是一个CONSTANT_UTF8_info类型的常量，该类型的结构表如下图所示：

类型	名称	数量
u1	tag	1
u2	length	1
u1	bytes	length

length属性说明这个UTF-8编码的字符串的长度是多少个字节，后边紧跟着length字节的连续数据表示一个使用UTF-8缩略编码表示的字符串。

说明：此处缩略编码与普通UTF编码的区别在于：从’\u0001’到’\u07ff’（相当于Ascii编码1到217）使用一个字节编码，从’\u0080’到 '\u007f’之间的字符使用两个字节编码，剩余部分按照普通UTF-8编码规则使用三个字节进行编码。

我们可以看到该字符串长度为 0x000f即有15个字节，然后紧接着15个字节构成了该字符串的值:com/test/BMWCar。

将前边两个常量结合在一起我们就了解到该类的全限定名为：com/test/BMWCar。

其他常量分析与之类似，我们计算出常量池在class中所占用的空间位置如下图所示：

访问标志(Access Flags)

常量池结束之后，紧接着的2个字节表示Class的访问标志（access_flags），这个标志用来识别类或者接口层次的访问信息，包括：这个Class是类还是接口；是否定义为public类型，是否定义为abstract类型；如果是类的话，是否定义为final等等。

具体的标志位及其含义如下表所示：

标志名称	标志值	含义
ACC_PUBLIC	0x0001	是否为public类型
ACC_FINAL	0x0010	是否被声明为final，只有类可设置
ACC_SUPER	0x0020	是否允许使用invokespecial字节码指令新语义，JDK1.0.2之后都为true
ACC_INTERFACE	0x0200	标志这是个接口
ACC_ABSTRACT	0x0400	是否是Abstract类型，对于抽象类或者接口来说为true，其他情况为false
ACC_SYNTHETIC	0x1000	标识这个类并非由用户代码产生
ACC_ANNOTATION	0x2000	标识这是一个注解
ACC_ENUM	0x4000	标识这是一个枚举
ACC_MODULE	0x8000	标识这是一个模块

access_flags中一共有16个标志位可以使用，当前只定义了9个，没有使用到的标志位一律为零（工程上的一种冗余设计思想，值得学习😁😊）。

结合我们的Class文件，可以看到该文件的访问标志为0x0021相当于0x0020 | 0x0001查询访问标志表可知，该类是一个public类型且可以使用invokespecial指令新语义的普通类。

类索引（This Class）、父类索引（Super Class）、接口（Interfaces）索引集合

    u2             this_class;//当前类
    u2             super_class;//父类
    u2             interfaces_count;//接口
    u2             interfaces[interfaces_count];//一个类可以实现多个接口

访问标识之后，紧接着的便是类索引、父类索引与接口索引集合。其中类索引、父类索引都是一个u2类型数据，而接口索引集合是一个u2类型的数据集合，这三项数据构成了Class文件的继承关系。

类索引用来确定这个类的全限定名，父类索引用来用于确定这个类的父类的全限定名。由于Java不允许多重继承，所以父类索引有只有一个(java.lang.Object类除外)。

接口索引集合就是用来描述这个类实现了哪些接口，这些接口将按照implements关键字（如果这个Class文件表示的是一个接口，则应当使用extends关键字）后的接口顺序从左到右排列在接口索引集合中。

类索引和父类索引使用两个u2类型的索引值表示，它们各自指向一个类型为CONSTANT_Class_info的类描述常量，进而找到一个定义在CONSTANT_Utf8_info类型中的索引全限定名字符串。

结合前边的Class文件，类索引查找全限定名的过程如下图所示：

首先根据从Class索引值为0x0001也即指向常量池中的第一个常量，该常量是一个CONSTANT_Class_info类型的数据，该数据的权限定名称指向了常量池中的第三个常量，第三个常量的常量值是com/test/BMWCar，将整个过程结合在一起我们就知道该类文件的全限定名为com/test/BMWCar。

父类索引的查找过程与之类似，此处不再详述，最终可以定位到该类文件的父类为java/lang/Object。

接口索引由于是集合类型，查找过程与类查找过程可能有些许不同：

首先找到第一个u2类型接口计数器，其值为0x0001也就是说该类文件实现了一个接口，其接口索引为0x0005即接口索引指向常量池中第五个常量。常量#5为一个CONSTAN_Class_info类型的常量，指向第六个CONSTANT_Utf8_info类型的常量#6，该常量的值为com/test/Car。

整个分析下来，我们可以得到该Class文件是一个实现了一个全限定名为com/test/Car接口的类。

字段表集合（Fields）

    u2             fields_count;//Class 文件的字段的个数
    field_info     fields[fields_count];//一个类会可以有个字段

接口索引后边紧跟着的就是字段表信息，字段表（field info）用于描述接口或类中声明的变量。字段包括类级变量以及实例变量，但不包括在方法内部声明的局部变量。

字段表的结构如下表所示：

类型	名称	数量	备注
u2	access_flags	1	字段的作用域（public、private、protected修饰符），是实例变量还是类变量，可否被序列化（transient修饰符），可变性（final），可见性（volatitle修饰符，是否强制从主内存读写）
u2	name_index	1	对常量池的引用，表示字段的简单名称
u2	descriptor_index	1	对常量池的引用，表示字段和方法的描述符
u2	attributes_count	1	一个字段可能会额外拥有一些属性，attributes_count用来存放属性的数量
attribute_info	attributes	attributes_count	存放属性的具体内容

字段访问access_flags的标志及其含义如下表所示：

权限名称	值	描述
ACC_PUBLIC	0x0001	public
ACC_PRIVATE	0x0002	private
ACC_PROTECTED	0x0004	protected
ACC_STATIC	0x0008	static，静态
ACC_FINAL	0x0010	final
ACC_VOLATILE	0x0040	volatile，不可和ACC_FIANL一起使用
ACC_TRANSIENT	0x0080	在序列化中被忽略的字段
ACC_SYNTHETIC	0x1000	由编译器产生，不存在于源代码中
ACC_ENUM	0x4000	enum

紧随access_flags标志的是name_index和descriptor_index，他们都是对常量池的引用。name_index代表着字段的简单名称，descriptor_index代表着字段的描述符。相比于全限定名和简单名称，方法和字段的描述符要复杂一些。

描述符的主要作用是用来描述字段的数据类型、方法和参数列表（包括数量类型以及顺序）和返回值。因而描述符在设计时，设计了一系列描述规则：

1. 基本数据类型（byte、char、double、float、int、long、short、boolean）以及代表无返回值的void类型都用一个大写字符来表示。
2. 对象类型则用字符L加上对象的全限定名来表示

描述符标识字含义如下表所示：

标识字符	含义
B	基本类型byte
C	基本类型char
D	基本类型double
F	基本类型float
I	基本类型int
J	基本类型long
S	基本类型short
Z	基本类型boolean
V	特殊类型void
L	对象类型，如Ljava/lang/Object;
[	数组类型，多个维度则有多个[

用描述符来描述方法时，按照先参数列表后返回值的顺序描述，参数列表按照参数的严格顺序放在一组“()”之内。

例如方法int getAge()的描述符为“()I”，方法void print(String msg)的描述符为“(Ljava/lang/String;)V”，方法int indexOf(int index, char[] arr)的描述符为“(I[C)I”

结合我们的Class文件，可以看到该类的第一个方法是构造方法，方法名称为com.test.BMWCar，描述符为()V，也即是一个入参为空且返回值为空的函数。

方法表集合（Methods）

u2             methods_count;//Class 文件的方法的数量
method_info    methods[methods_count];//一个类可以有个多个方法

字段表集合结束之后，紧接着就是方法表集合，与字段表的结构一样，一次包括访问标志（access_flags)、名称索引（name_index)、描述符(descriptor_index)、属性表集合（attributes)几项，具体结构如下表所示：

类型	描述	备注
u2	access_flags	记录方法的访问标志
u2	name_index	常量池中的索引项，指定方法的名称
u2	descriptor_index	常量池中的索引项，指定方法的描述符
u2	attributes_count	attributes包含的项目数
attribute_info	attributes[attributes_count]	存放属性的具体内容

具体方法标志及其含义如下表所示：

权限名称	值	描述
ACC_PUBLIC	0x0001	public
ACC_PRIVATE	0x0002	private
ACC_PROTECTED	0x0004	protected
ACC_STATIC	0x0008	static，静态
ACC_FINAL	0x0010	final
ACC_SYNCHRONIZED	0x0020	方法是否为synchronized
ACC_BRIDGE	0x0040	方法是否是由编译器产生的桥接方法
ACC_VARARGE	0x0080	方法是否接受不定参数
ACC_NATIVE	0x0100	方法是否为native
ACC_ABSTRACT	0x0400	方法是否为abstract
ACC_SYNTHETIC	0x0800	方法是否为strictfp
ACC_SYNTHETIC	0x1000	由编译器产生，不存在于源代码中

与属性表的方法标志进行比较，我们不难发现，两者大体上是类似的，但有诸多不同之处：

因为volatile关键字和transient关键字不能够修饰方法，所以方法表的访问标志中没有了ACC_VOLATILE标志和ACC_TRANSIENT标志。与之相对应的，synchronized、native、strictfp和abstract等关键字可以修改方法但不能修饰属性，因此增加了ACC_SYNCHRONIZED、ACC_NATIVE、ACC_SYNTHETIC、ACC_ABSTRACT。

分析到这里，可能会有小伙伴有疑问了：前面说的好像都只是方法的定义，那方法的主体逻辑代码怎么描述呢？

简单来说，方法体中的Java代码，经过Javac编译成字节码指令之后，存放在方法属性中的一个名为Code的属性里面了。

结合我们的Class文件可以看到，该文件中有一个drive()方法，该方法的入参和返回值都为空，访问限定符为public。

当然与字段表集合相应的，如果父类方法在子类中被重写（Override），方法表集合中就不会出现来自父类的方法信息。如果未被覆盖就有可能出现由编译器自动添加的方法，最常见的便是类构造器（<clinit>()）以及实例构造器<init>()方法。

结合我们的Class文件可以看到，该Class文件也是具有<init>()方法的。

属性表集合（Attributes）

   u2             attributes_count;//此类的属性表中的属性数
   attribute_info attributes[attributes_count];//属性表集合

属性表（attribute_info）前边实际上已经提到了数次，Class文件、字段表、方法表都可以携带自己的属性表集合，以描述某些场景专有信息。

与其他数据项目的要求严格的顺序、长度和内容不同，属性表集合的限制稍微宽松一点，不要求各个属性的严格顺序，只要不与已有属性名重复，任何人实现的编译器都可以向属性表中写入自己定义的属性信息，Java虚拟机在运行时会忽略掉它所不熟悉的信息。

由于Jave当前支持的属性种类很多已经达到了29项，因而此处只列出常见的几种重要属性：

属性名称	使用位置	含义
Code	方法表	Java代码编译成的字节码指令
ConstantValue	字段表	final关键字定义的常量值
Deprecated	类、方法表、字段表	被声明为deprecated的方法和字段
Exceptions	方法表	方法抛出的异常
InnerClasses	类文件	内部类列表
LineNumberTable	Code属性	Java源码的行号与字节码指令的对应关系
LocalVariableTable	Code属性	方法的局部变量描述
SourceFile	类文件	源文件名称
Synthetic	类、方法表、字段表	标识方法或字段为编译器自动生成的

Code属性

Java方法里的代码被编译处理后，变为字节码指令存储在方法表的Code属性里，但并不是所有的方法表里都有Code属性，例如接口或抽象类中的方法就可能没有该属性。

Code属性如下表所示：

类型	名称	含义
u2	attribute_name_index	属性名称索引
u4	attribute_length	属性长度
u2	max_stack	操作数栈深度的最大值
u2	max_locals	局部变量表所需的存储空间
u4	code_length	字节码长度
u1	code[code_length]	存储字节码指令的一系列字节流
u2	exception_table_length	异常表长度
exception_info	exception_table	异常表的值
u2	attributes_count	属性数量
attribute_info	attributes[attributes_count]	属性的值

结合我们的Class文件可以看到其Code属性如下：

从图中可以看出，Code属性本身也是一个复合属性，其中包含了其他属性，比如包含了LineNumberTable和LocalVariableTable。

ConstantValue属性

只有当一个字段被声明为static final时，并且该字段是基本数据类型或String类型时，编译器才会在字段的属性表集合中增加一个名为ConstantValue的属性，所以ConstantValue属性只会出现在字段表中，其数据结构为：

类型	名称	含义
u2	attribute_name_index	属性名称索引
u2	attribute_length	属性长度
u2	constantvalue_index	常量池常量的索引

总结

Class文件是Java虚拟机执行引擎的数据入口，也是Java技术体系的基础支柱之一，因而学习Class文件的结构很有意义。本文主要讲解了Class文件结构中的各个组成部分，以及每个部分的定义、数据结构和使用方法。并结合一个例子（文中有代码，引用处附带有链接），讲解了Class文件是如何被存储和访问的。

参考

1. Java Class文件结构解析
2. 类文件结构
3. 《深入理解JVM虚拟机》
4. 文中使用的class文件BMWCar.class