java class文件详解-亚博电竞手机版

java class文件中包含以下信息：

classfile {  u4 magic;                                 //模数 u2 minor_version;                         //次版本号 u2 major_version;                         //主版本号 u2 constant_pool_count;                   //常量池大小 cp_info constant_pool[constant_pool_count-1];    //常量池 u2 access_flags;                     //类和接口层次的访问标志（通过|运算得到） 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];    //属性表  }

1. 通过实例来看

public interface intera {      void intera(); }  public interface interb {     string interb(int i); } public interface interc {     void interc(); } public class base implements intera {      private int baseint;     protected string basestring;      public int getbaseint() {         return baseint;     }     public void setbaseint(int baseint) {         this.baseint = baseint;     }      @override     public void intera() {         system.out.println("the intera in base");     } }    public class sub extends base implements interb, interc {      private int subint;     private static string substring;     private static object subobject;      public int getsubint() {         return subint;     }     public void setsubint(int subint) {         this.subint = subint;     }     public static string getsubstring() {         return substring;     }     public static void setsubstring(string substring) {         sub.substring = substring;     }     public static object getsubobject() {         return subobject;     }     public static void setsubobject(object subobject) {         sub.subobject = subobject;     }      @override     public void interc() {         system.out.println("the interc in sub");     }      @override     public string interb(int i) {         return "the interb in sub";     } }

我们使用winhex查看sub类的.class文件：

2. 魔数

作用：确定该文件是否是虚拟机可接受的class文件。java的魔数统一为 0xcafebabe (来源于一款咖啡)。

区域：文件第0~3字节。

3. 版本号

作用：表示class文件的版本，由minorversion和majorversion组成。

区域：文件第4~7字节。

如

51代表，jdk为1.7.0

需要注意的是java版本号是从45开始的，大版本发布，主版本号 1.高版本的jdk能向下兼容以前版本的class文件，但不兼容以后版本的class文件。

4. 常量池

常量池的大小是不固定的，根据你的类中的常量的多少而定，所以在常量池的入口，放置了一个u2类型的表示常量池中常量个数的常量池容量计数器。计数器从1开始，第0位有特殊含义，表示指向常量池的索引值数据不引用任何一个常量池项目。池中的数据项就像数组一样是通过索引访问的。

我们可以清楚的看到，我们常量池中有63-1=62个常量。这些常量是什么呢？

要存放字面量literal和符号引用symbolic references。

字面量可能是文本字符串，或final的常量值。

符号引用包括以下：

• 类或接口全限定名 full qualified name
• 字段名称和描述符 descriptor
• 方法名称和描述符

我们使用反编译工具查看一下：

e:\program\jvm\bin\com\gissky\clazz>javap -v sub.class classfile /e:/program/jvm/bin/com/gissky/clazz/sub.class   last modified 2015-2-22; size 1363 bytes   md5 checksum 2dc77c79e4790422407eb7092085883c   compiled from "sub.java" public class com.gissky.clazz.sub extends com.gissky.clazz.base implements com.gissky.clazz.interb,com.gissky.clazz.interc   sourcefile: "sub.java"   minor version: 0   major version: 51   flags: acc_public, acc_super constant pool:    #1 = class              #2             //  com/gissky/clazz/sub    →类和接口的全限定名        #2 = utf8               com/gissky/clazz/sub    #3 = class              #4             //  com/gissky/clazz/base    #4 = utf8               com/gissky/clazz/base    #5 = class              #6             //  com/gissky/clazz/interb    #6 = utf8               com/gissky/clazz/interb    #7 = class              #8             //  com/gissky/clazz/interc    #8 = utf8               com/gissky/clazz/interc    #9 = utf8               subint    #10 = utf8              i    #11 = utf8              substring   #12 = utf8               ljava/lang/string;   #13 = utf8               subobject   #14 = utf8               ljava/lang/object;   #15 = utf8                  #16 = utf8               ()v   #17 = utf8               code   #18 = methodref          #3.#19         //  com/gissky/clazz/base."":()v   #19 = nameandtype        #15:#16        //  "":()v   #20 = utf8               linenumbertable   #21 = utf8               localvariabletable   #22 = utf8               this   #23 = utf8               lcom/gissky/clazz/sub;   #24 = utf8               getsubint   #25 = utf8               ()i    #26 = fieldref           #1.#27         //  com/gissky/clazz/sub.subint:i         → 类中字段的符号引用   #27 = nameandtype        #9:#10         //  subint:i                                           → 类中字段的部分符号引用之名称和类型   #28 = utf8               setsubint   #29 = utf8               (i)v   #30 = utf8               getsubstring   #31 = utf8               ()ljava/lang/string;   #32 = fieldref           #1.#33         //  com/gissky/clazz/sub.substring:ljava/lang/string;   #33 = nameandtype        #11:#12        //  substring:ljava/lang/string;   #34 = utf8               setsubstring   #35 = utf8               (ljava/lang/string;)v   #36 = utf8               getsubobject   #37 = utf8               ()ljava/lang/object;   #38 = fieldref           #1.#39         //  com/gissky/clazz/sub.subobject:ljava/lang/object;   #39 = nameandtype        #13:#14        //  subobject:ljava/lang/object;   #40 = utf8               setsubobject   #41 = utf8               (ljava/lang/object;)v   #42 = utf8               interc   #43 = fieldref           #44.#46        //  java/lang/system.out:ljava/io/printstream;   #44 = class              #45            //  java/lang/system   #45 = utf8               java/lang/system   #46 = nameandtype        #47:#48        //  out:ljava/io/printstream;   #47 = utf8               out   #48 = utf8               ljava/io/printstream;   #49 = string             #50            //  the interc in sub   #50 = utf8               the interc in sub   #51 = methodref          #52.#54        //  java/io/printstream.println:(ljava/lang/string;)v   #52 = class              #53            //  java/io/printstream   #53 = utf8               java/io/printstream   #54 = nameandtype        #55:#35        //  println:(ljava/lang/string;)v   #55 = utf8               println   #56 = utf8               interb   #57 = utf8               (i)ljava/lang/string;   #58 = string             #59            //  the interb in sub                                    →方法中用到的string常量   #59 = utf8               the interb in sub   #60 = utf8               i   #61 = utf8               sourcefile   #62 = utf8               sub.java

常量池中的项目类型如下：

• constant_utf8_info tag标志位为1, utf-8编码的字符串
• constant_integer_info tag标志位为3， 整形字面量
• constant_float_info tag标志位为4， 浮点型字面量
• constant_long_info tag标志位为5， 长整形字面量
• constant_double_info tag标志位为6， 双精度字面量
• constant_class_info tag标志位为7， 类或接口的符号引用
• constant_string_info tag标志位为8，字符串类型的字面量
• constant_fieldref_info tag标志位为9, 字段的符号引用
• constant_methodref_info tag标志位为10，类中方法的符号引用
• constant_interfacemethodref_info tag标志位为11, 接口中方法的符号引用
• constant_nameandtype_info tag 标志位为12，字段和方法的名称以及类型的符号引用

5. 类或接口访问标志

表示类或者接口方面的访问信息，比如class表示的是类还是接口，是否为public、static、final等。，下面我们就来看看testclass的访问标示。class的访问标志值为0×0021：

根据前面说的各种访问标示的标志位，我们可以知道：0×0021=0×0001|0×0020 也即acc_public 和 acc_super为真，其中acc_public大家好理解，acc_super是jdk1.2之后编译的类都会带有的标志。

6. 类索引、父类索引与接口索引集合

class文件中由这3项数据来确定类的继承关系。

类索引和父类索引都是指向常量池中的常量索引：

紧接着后面是一个接口的计数器和接口描述符：

7. 字段表集合

作用：描述接口或者类中声明的类变量以及实例变量，不包括方法中的局部变量。

紧接着接口索引集合之后的2字节是字段计数器：

表示我们类中有3个字段，这里便是subint、substring、subobject 3个字段。紧接其后的是字段表，字段表结构为：

field_info {      u2                               access_flags;      u2                               name_index;      u2                               descriptor_index;      u2                               attributes_count;      attribute_info          attributes[attributes_count];  }

access_flags项的值是用于定义字段被访问权限和基础属性的掩码标志。取值范围如下表：

描述符标识字符含义：

v 表示特殊类型void。

对于数组类型，每一个维度将使用一个前置的”["字符来描述，如一个定义的"java.lang.string[][]“类型的二维数组，将被记录为:”[[ljava/lang/string;",一个整型数组"int[]“将被记录为”[i"

父类中的字段不会出现在子类的字段表中。

8. 方法表集合

字段表集合结束后便是方法表集合。

作用：描述该类中的方法。

和字段表一样，使用一个u2类型的方法计数器，记录该类中方法的个数。

表示我们的类中有9个方法。

方法表的结构如下图所示

其中name_index和descriptor_index表示的是方法的名称和描述符，他们分别是指向常量池的索引。这里需要结解释一下方法的描述符，方法的描述符的结构为：（参数列表）返回值，比如public int instancemethod(int param)的描述符为：（i）i，表示带有一个int类型参数且返回值也为int类型的方法，方法java.lang.string.tostring()的描述符为"()ljava/lang/string;"，int indexof(char[] source,int sourceoffset,int sourcecount,char[] target int targetoffset,int targetcount,int fromindex) 表示为([cii[cii)i。接下来就是属性数量以及属性表了，方法表和字段表虽然都有 属性数量和属性表，但是他们里面所包含的属性是不同。

如果父类方法在子类中没有被重写（@override），方法表中就不会出现来自父类的方法信息。

9. 属性表集合

上面的方法表中我们就看到方法有一个code的属性。在本节我们将阐述这些属性：

code属性：

该属性里主要存放由javac编译器处理后得到的字节码指令。

其中attribute_name_index指向常量池中值为code的常量，attribute_length的长度表示code属性表的长度（这里 需要注意的时候长度不包括attribute_name_index和attribute_length的6个字节的长度）。

max_stack表示最大栈深度，虚拟机在运行时根据这个值来分配栈帧中操作数的深度，而max_locals代表了局部变量表所需的存储空间。

max_locals的单位为slot，slot是虚拟机为局部变量分配内存的最小单元，在运行时，对于不超过32位类型的数据类型，比如 byte,char,int等占用1个slot，而double和long这种64位的数据类型则需要分配2个slot，另外max_locals的值并不是所有局部变量所需要的内存数量之和，因为slot是可以重用的，当局部变量超过了它的作用域以后，局部变量所占用的slot就会被重用。方法参数、显示异常处理器的参数、方法体中定义的局部变量都要使用局部变量表来存放。

code_length代表了字节码指令的数量，而code表示的是字节码指令，从上图可以知道code的类型为u1,一个u1类型的取值为0x00-0xff,对应的十进制为0-255，目前虚拟机规范已经定义了200多条指令。

exception_table_length以及exception_table分别代表方法对应的异常信息。

attributes_count和attribute_info分别表示了code属性中的属性数量和属性表，从这里可以看出class的文件结构中，属性表是很灵活的，它可以存在于class文件，方法表，字段表以及code属性中。

修改一下sub中的interb方法：

 @override      public int interb(int i){         int x=0;         try{             x =i;             return x;         }catch(exception e){             x=-1;             return x;         }finally{             x=3;         }     }

大家不妨先猜一下这个函数的结果是什么？假如在try块中发生异常，结构又是什么？我相信对java语言熟悉的朋友，肯定知道答案。

使用反编译工具查看：

public int interb(int);      flags: acc_public      code:        stack=2, locals=6, args_size=2           0: iconst_0           1: istore_2           2: iload_2           3: iload_1           4: iadd           5: istore_2           6: iload_2           7: istore        5           9: iconst_3          10: istore_2          11: iload         5          13: ireturn          14: astore_3          15: iconst_m1          16: istore_2          17: iload_2          18: istore        5          20: iconst_3          21: istore_2          22: iload         5          24: ireturn          25: astore        4          27: iconst_3          28: istore_2          29: aload         4          31: athrow        exception table:           from    to   target    type               2       9       14         class java/lang/exception               2       9       25         any              14      20    25         any        linenumbertable:          line 35: 0          line 37: 2          line 38: 6          line 43: 9          line 38: 11          line 39: 14          line 40: 15          line 41: 17          line 43: 20          line 41: 22          line 42: 25          line 43: 27          line 44: 29        localvariabletable:          start  length  slot  name   signature                 0      32        0      this         lcom/gissky/clazz/sub;                 0      32        1        i             i                 2      30        2        x            i                15    10        3        e            ljava/lang/exception;        stackmaptable: number_of_entries = 2             frame_type = 255 /* full_frame */            offset_delta = 14            locals = [ class com/gissky/clazz/sub, int, int ]            stack = [ class java/lang/exception ]             frame_type = 74 /* same_locals_1_stack_item */            stack = [ class java/lang/throwable ]  }

从 args_size=2这条反编译代码，我们可以知道，在public int interb(int i)这个方法中有6个局部变量，2个参数，可是我们的函数中明明只有一个参数么……这是因为编译器会为每一个实例函数包括构造器添加一个参数this，在jvm调用该方法的时候会该形参传递一个实参—方法所在对象的自身。

exception table:

from to target type

2 9 14 class java/lang/exception

2 9 25 any

14 20 25 any

上表表头表示，当字节码在form行到to行（不包括to行）出现类型为type的异常，则转到第target行继续处理。

从方法的异常表中，我们可以看到这个函数有3条执行路径：

这里我们插入阐述一下linenumbertable表的含义：它表示java源码行号与字节码行号之间的对应关系。

对照上图，我们能清晰的看出这3条路径。

知道了该方法执行的3条路径，我们也就知道刚才我们的那个问题有3个答案：没有异常是为x i；try块中出现exception类型的错误时，返回-1；出现exception以外的任何异常方法非正常结束，没有返回值。

localvariabletable:

start length slot name signature

0 32 0 this lcom/gissky/clazz/sub;

0 32 1 i i

2 30 2 x i

15 10 3 e ljava/lang/exception;

localvariabletable表示局部变量表，描述方法中局部变量。

如果你对返回的答案能理解的话，那么我相信你也肯定知道，我们函数中只有4个参数，但max_locals却等于6。不懂的话仔细看一下code中字节码的执行过程变可以理解了。

一个方法在执行时需要多大的局部变量空间在编译时期就知道了，方法执行期间不会改变局部变量表的大小。

signature 属性：

该属性是在jdk1.5新增的。该属性可用于类、属性表和方法表结构的属性表中。使用泛型签名如果包含了类型变量（type variables）或参数化类型（parameterized types），则signature 属性会为它记录泛型签名信息。当我们要泛型类中拿到泛型的实际类型的时候非常有用。

实例：

在使用hibernate时，我习惯将为dao层封装一个泛型基类，来放置一些通用的方法，而hibernate有很多方法都要传递一个pojo的类型，然后进行查询，如load方法。我们构建这样的一个基类：

public abstract class basedaoimpl extends hibernatedaosupport implements basedao

那么load中要使用的pojo类型便是t的实际类型。怎么来那倒这个属性呢？这里边要使用到signature属性了。

public abstract class basedaoimpl extends hibernatedaosupport implements basedao {      private class entityclass;      @suppresswarnings("unchecked")     public basedaoimpl() {         //class orgdao extends basedaoimpl implements orgdao {}         class c = this.getclass(); //返回的是使用new创建的泛型类对应的对象的class对象。         type type = c.getgenericsuperclass(); //取得该对象的泛型类         //取得泛型对应的真正的class，并放到数组中         type[] types = ((parameterizedtype)type).getactualtypearguments();         entityclass = (class) types[0];     }

这时，getbyid中就可以直接使用了：

    public t getbyid(pk id) {         return (t) gethibernatetemplate().load(entityclass, id);     }