用javap命令查看Java的static块在.class文件中的表示

public class Test
{
	static
	{
		i = 20;
	}
	public static int i = 10;
	public static void main(String[] args)
	{
		System.out.println(i);
	}
	
}

//以上为Test.java文件

Java静态变量的初始化（static块的本质）

转自:

在网上看到了下面的一段代码：

[java] view plain copy print ?

1. public class Test {  
2.     static {  
3.         _i = 20;  
4.     }  
5.     public static int _i = 10;  
6.       
7.     public static void main(String[] args) {  
8.         System.out.println(_i);  
9.     }  
10. }  

public class Test { static { _i = 20; } public static int _i = 10; public static void main(String[] args) { System.out.println(_i); } }

上述代码会打印出什么结果来呢？10还是20？本文将以此代码为引子，着重讨论一下静态变量的初始化问题。

问题1：静态变量如何初始化

Java类中可以定义一个static块，用于静态变量的初始化。如：

[java] view plain copy print ?

1. public class Test {  
2.     public static int _i;  
3.     static {  
4.         _i = 10;  
5.     }  
6. }  

public class Test { public static int _i; static { _i = 10; } }

当然最常用的初始化静态变量的操作是在声明变量时直接进行赋值操作。如：

[java] view plain copy print ?

1. public class Test {  
2.     public static int _i = 10;  
3. }  

public class Test { public static int _i = 10; }

那么上述两例在本质上有什么区别吗？回答是没有区别。两例代码编译之后的字节码完全一致，通过 “javap -c”查看到的字节码如下：

public class Test extends java.lang.Object{
public static int i;

public Test();
  Code:
   0:   aload_0
   1:   invokespecial   #1; //Method java/lang/O
   4:   return

public static void main(java.lang.String[]);
  Code:
   0:   getstatic       #2; //Field java/lang/Sy
   3:   getstatic       #3; //Field i:I
   6:   invokevirtual   #4; //Method java/io/Pri
   9:   return

static {};
  Code:
   0:   bipush  20
   2:   putstatic       #3; //Field i:I
   5:   bipush  10
   7:   putstatic       #3; //Field i:I
   10:  return

}

通过字节码还可以看出，当类的定义中不含有static块时，编译器会为该类提供一个默认的static块。当然这是在含有静态变量初始化操作的前提下。如果静态变量没有初始化操作，则编译器不会为之提供默认的static块。如：

[java] view plain copy print ?

1. public class Test {  
2.     public static int _i;  
3. }  

public class Test { public static int _i; }

其字节码的表现形式为：

public class Test extends java.lang.Object{
public static int _i;

 

public Test();
  Code:
   0: aload_0
   1: invokespecial #1; //Method java/lang/Object."<init>":()V
   4: return

 

}

由于静态变量是通过赋值操作进行初始化的，因此可以通过静态函数返回值的方式为其初始化。如：

[java] view plain copy print ?

1. public class Test {  
2.     public static int _i = init();  
3.       
4.     private static int init() {  
5.         return 10;  
6.     }  
7. }  

public class Test { public static int _i = init(); private static int init() { return 10; } }

其本质与下面的代码相同：

[java] view plain copy print ?

1. public class Test {  
2.     public static int _i;  
3.     static {  
4.         _i = init();  
5.     }  
6.       
7.     private static int init() {  
8.         return 10;  
9.     }  
10. }  

public class Test { public static int _i; static { _i = init(); } private static int init() { return 10; } }

问题2：JDK如何处理static块

类定义中可以存在多个static块吗？回答是可以。如：

[java] view plain copy print ?

1. public class Test {  
2.     public static int _i;  
3.     static {  
4.         _i = 10;  
5.     }  
6.       
7.     public static void main(String[] args) {  
8.     }  
9.       
10.     static {  
11.         _i = 20;  
12.     }  
13. }  

public class Test { public static int _i; static { _i = 10; } public static void main(String[] args) { } static { _i = 20; } }

此类编译之后的字节码为：

public class Test extends java.lang.Object{
public static int _i;

 

public Test();
  Code:
   0: aload_0
   1: invokespecial #1; //Method java/lang/Object."<init>":()V
   4: return

 

public static void main(java.lang.String[]);
  Code:
   0: return

 

static {};
  Code:
   0: bipush 10
   2: putstatic #2; //Field _i:I
   5: bipush 20
   7: putstatic #2; //Field _i:I
   10: return

 

}

观察static{}部分可以看出，上例的代码与下面的代码效果一致：

[java] view plain copy print ?

1. public class Test {  
2.     public static int _i;  
3.       
4.     public static void main(String[] args) {  
5.     }  
6.       
7.     static {  
8.         _i = 10;  
9.         _i = 20;  
10.     }  
11. }  

public class Test { public static int _i; public static void main(String[] args) { } static { _i = 10; _i = 20; } }

此例可以证明，不仅类定义中可以有多个static块，而且在编译时编译器会将多个static块按照代码的前后位置重新组合成一个static块。

问题3：如何看待静态变量的声明

静态变量存放在常量池之中。如何证明呢？如：

[java] view plain copy print ?

1. public class Test {  
2.     public static int _i = 10;  
3. }  

public class Test { public static int _i = 10; }

使用“javap -c -verbose”查看其字节码的内容如下：

public class Test extends java.lang.Object
  SourceFile: "Test.java"
  minor version: 0
  major version: 49
  Constant pool:
const #1 = Method #4.#14; //  java/lang/Object."<init>":()V
const #2 = Field #3.#15; //  Test._i:I
const #3 = class #16; //  Test
const #4 = class #17; //  java/lang/Object
const #5 = Asciz _i;
const #6 = Asciz I;
const #7 = Asciz <init>;
const #8 = Asciz ()V;
const #9 = Asciz Code;
const #10 = Asciz LineNumberTable;
const #11 = Asciz <clinit>;
const #12 = Asciz SourceFile;
const #13 = Asciz Test.java;
const #14 = NameAndType #7:#8;//  "<init>":()V
const #15 = NameAndType #5:#6;//  _i:I
const #16 = Asciz Test;
const #17 = Asciz java/lang/Object;

 

{
public static int _i;

public Test();
  Code:
   Stack=1, Locals=1, Args_size=1
   0: aload_0
   1: invokespecial #1; //Method java/lang/Object."<init>":()V
   4: return
  LineNumberTable:
   line 2: 0

 

static {};
  Code:
   Stack=1, Locals=0, Args_size=0
   0: bipush 10
   2: putstatic #2; //Field _i:I
   5: return
  LineNumberTable:
   line 3: 0

 

}

我们看到，常量池中const #2指向的就是Test._i，也就是静态变量。静态变量被保存到常量池中的工作原理这里不深入讨论。在此需要注意的是：

• 静态变量的声明与初始化是两个不同的操作；
• 静态变量的声明在编译时已经明确了内存的位置。

如：

[java] view plain copy print ?

1. public class Test {  
2.     public static int _i = 10;  
3. }  

public class Test { public static int _i = 10; }

上述代码的本质可以视为：

[java] view plain copy print ?

1. public class Test {  
2.     // 静态变量的声明  
3.     public static int _i;  
4.   
5.     // 静态变量的初始化  
6.     static {  
7.         _i = 10;  
8.     }  
9. }  

public class Test { // 静态变量的声明 public static int _i; // 静态变量的初始化 static { _i = 10; } }

由于静态变量的声明在编译时已经明确，所以静态变量的声明与初始化在编码顺序上可以颠倒。也就是说可以先编写初始化的代码，再编写声明代码。如：

[java] view plain copy print ?

1. public class Test {  
2.     // 静态变量的初始化  
3.     static {  
4.         _i = 10;  
5.     }  
6.       
7.     // 静态变量的声明  
8.     public static int _i;  
9. }  

public class Test { // 静态变量的初始化 static { _i = 10; } // 静态变量的声明 public static int _i; }

对初始问题的解答

解答了上述三个问题，让我们再来看看开篇提到的问题。代码如下：

[java] view plain copy print ?

1. public class Test {  
2.     static {  
3.         _i = 20;  
4.     }  
5.     public static int _i = 10;  
6.       
7.     public static void main(String[] args) {  
8.         System.out.println(_i);  
9.     }  
10. }  

public class Test { static { _i = 20; } public static int _i = 10; public static void main(String[] args) { System.out.println(_i); } }

其本质可以用下面的代码表示：

[java] view plain copy print ?

1. public class Test {  
2.     static {  
3.         _i = 20;  
4.     }  
5.     public static int _i;  
6.     static {  
7.         _i = 10;  
8.     }  
9.       
10.     public static void main(String[] args) {  
11.         System.out.println(_i);  
12.     }  
13. }  

public class Test { static { _i = 20; } public static int _i; static { _i = 10; } public static void main(String[] args) { System.out.println(_i); } }

再简化一下，可以表示为：

[java] view plain copy print ?

1. public class Test {  
2.     public static int _i;  
3.       
4.     static {  
5.         _i = 20;  
6.         _i = 10;  
7.     }  
8.       
9.     public static void main(String[] args) {  
10.         System.out.println(_i);  
11.     }  
12. }  

public class Test { public static int _i; static { _i = 20; _i = 10; } public static void main(String[] args) { System.out.println(_i); } }

至此，代码已经明确告诉我们打印结果是什么了！

Java字节码指令集 

http://blog.163.com/lihui_2000/blog/static/665969402012194530772/

字节码指令集

　　Java虚拟机的指令由一个字节长度的、代表着某种特定操作含义的操作码（Opcode）以及跟随其后的零至多个代表此操作所需参数的操作数（Operands）所构成。

　　对于大部分为与数据类型相关的字节码指令，他们的操作码助记符中都有特殊的字符来表明专门为哪种数据类型服务：i代表对int类型的数据操作，l代表long，s代表short，b代表byte，c代表char，f代表float，d代表double，a代表reference。

　　加载和存储指令：

将一个局部变量加载到操作栈的指令包括有：iload、iload_<n>、lload、lload_<n>、fload、fload_<n>、dload、dload_<n>、aload、aload_<n>
将一个数值从操作数栈存储到局部变量表的指令包括有：istore、istore_<n>、lstore、lstore_<n>、fstore、fstore_<n>、dstore、dstore_<n>、astore、astore_<n>
将一个常量加载到操作数栈的指令包括有：bipush、sipush、ldc、ldc_w、ldc2_w、aconst_null、iconst_m1、iconst_<i>、lconst_<l>、fconst_<f>、dconst_<d>
扩充局部变量表的访问索引的指令：wide

　　运算指令：

加法指令：iadd、ladd、fadd、dadd
减法指令：isub、lsub、fsub、dsub
乘法指令：imul、lmul、fmul、dmul
除法指令：idiv、ldiv、fdiv、ddiv
求余指令：irem、lrem、frem、drem
取反指令：ineg、lneg、fneg、dneg
位移指令：ishl、ishr、iushr、lshl、lshr、lushr
按位或指令：ior、lor
按位与指令：iand、land
按位异或指令：ixor、lxor
局部变量自增指令：iinc
比较指令：dcmpg、dcmpl、fcmpg、fcmpl、lcmp

　　类型转换指令：

　　Java虚拟机对于宽化类型转换直接支持，并不需要指令执行，包括：

int类型到long、float或者double类型
long类型到float、double类型
float类型到double类型

　　窄化类型转换指令包括有：i2b、i2c、i2s、l2i、f2i、f2l、d2i、d2l和d2f。但是窄化类型转换很可能会造成精度丢失。

　　对象创建与操作指令：

创建类实例的指令：new
创建数组的指令：newarray，anewarray，multianewarray
访问类字段（static字段，或者称为类变量）和实例字段（非static字段，或者成为实例变量）的指令：getfield、putfield、getstatic、putstatic
把一个数组元素加载到操作数栈的指令：baload、caload、saload、iaload、laload、faload、daload、aaload
将一个操作数栈的值储存到数组元素中的指令：bastore、castore、sastore、iastore、fastore、dastore、aastore
取数组长度的指令：arraylength
检查类实例类型的指令：instanceof、checkcast

　　操作数栈管理指令：

　　Java虚拟机提供了一些用于直接操作操作数栈的指令，包括：pop、pop2、dup、dup2、dup_x1、dup2_x1、dup_x2、dup2_x2和swap；

　　控制转移指令：

条件分支：ifeq、iflt、ifle、ifne、ifgt、ifge、ifnull、ifnonnull、if_icmpeq、if_icmpne、if_icmplt, if_icmpgt、if_icmple、if_icmpge、if_acmpeq和if_acmpne。
复合条件分支：tableswitch、lookupswitch
无条件分支：goto、goto_w、jsr、jsr_w、ret

　　方法调用和返回指令：

invokevirtual指令用于调用对象的实例方法，根据对象的实际类型进行分派（虚方法分派），这也是Java语言中最常见的方法分派方式。
invokeinterface指令用于调用接口方法，它会在运行时搜索一个实现了这个接口方法的对象，找出适合的方法进行调用。
invokespecial指令用于调用一些需要特殊处理的实例方法，包括实例初始化方法（§2.9）、私有方法和父类方法。
invokestatic指令用于调用类方法（static方法）。

而方法返回指令则是根据返回值的类型区分的，包括有ireturn（当返回值是boolean、byte、char、short和int类型时使用）、lreturn、freturn、dreturn和areturn，另外还有一条return指令供声明为void的方法、实例初始化方法、类和接口的类初始化方法使用

　　抛出异常指令：

athrow

 关于Java虚拟机中的字节码指令

源代码经过编译器编译之后便会生成一个字节码文件，字节码是一种二进制的类文件，它的内容是JVM的指令，而不像C、C++经由编译器直接生成机器码。我们不用担心生成的字节码文件的兼容性，因为所有的JVM全部遵守Java虚拟机规范，也就是说所有的JVM环境都是一样的，这样一来字节码文件可以在各种JVM上运行。 当然也包括KVM。

每一个线程都有一个保存帧的栈。在每一个方法调用的时候创建一个帧。一个帧包括了三个部分：操作栈，局部变量数组，和一个对当前方法所属类的常量池的引用。

局部变量数组也被称之为局部变量表，它包含了方法的参数，也用于保存一些局部变量的值。参数值得存放总是在局部变量数组的index0开始的。如果当前帧是由构造函数或者实例方法创建的，那么该对象引用将会存放在location0处，然后才开始存放其余的参数。

局部变量表的大小由编译时决定，同时也依赖于局部变量的数量和一些方法的大小。操作栈是一个（LIFO）栈，用于压入和取出值，其大小也在编译时决定。某些opcode指令将值压入操作栈，其余的opcode指令将操作数取出栈。使用它们后再把结果压入栈。操作栈也用于接收从方法中返回的值。

以HelloWorld程序为例，经过命令：

E:\JavaExe>javap -c HelloWorld>HelloWorld.bytecode

就会在目录下生成一个字节码文件，用编辑器打开后

 

Compiled from "HelloWorld.java"

class HelloWorld extends java.lang.Object{

public HelloWorld(java.lang.String,int);

  Code:

   0:      aload_0

   1:      invokespecial #1; //Method java/lang/Object."<init>":()V

   4:      aload_0

   5:      ldc   #2; //String

   7:      putfield   #3; //Field name:Ljava/lang/String;

   10:    aload_0

   11:    iconst_0

   12:    putfield   #4; //Field idNumber:I

   15:    aload_0

   16:    aload_1

   17:    putfield   #3; //Field name:Ljava/lang/String;

   20:    aload_0

   21:    iload_2

   22:    putfield   #4; //Field idNumber:I

   25:    aload_0

   26:    aload_1

   27:    iload_2

   28:    invokevirtual  #5; //Method StoreData:(Ljava/lang/String;I)V

   31:    return

 

public void StoreData(java.lang.String,int);

  Code:

   0:      bipush    90

   2:      istore_2

   3:      return

 

void print(AnotherClass);

  Code:

   0:      aload_1

   1:      bipush    10

   3:      putfield   #6; //Field AnotherClass.a:I

   6:      new #7; //class AnotherClass

   9:      dup

   10:    invokespecial #8; //Method AnotherClass."<init>":()V

   13:    astore_1

   14:    aload_1

   15:    bipush    20

   17:    putfield   #6; //Field AnotherClass.a:I

   20:    return

 

}

 

以上是经过编译后的HelloWorld的字节码文件。我们可以对照源文件来查看一些重要的指令。

class HelloWorld

{

     private   String name = "";

     private  int idNumber = 0;

     public HelloWorld(String strName, int num)

     {

      

        name = strName;

        idNumber = num;

        StoreData(strName,num);

     }

  public  void StoreData(String str,int i)

  {

        i = 90;

  }

  void print(AnotherClass another)

  {

         another.a=10;

         another=new AnotherClass();

         another.a=20;

   }

 

}

class AnotherClass

{

    public int a = 0;

   

}

void print(AnotherClass);

  Code:

   0:      aload_1

   1:      bipush    10

   3:      putfield   #6; //Field AnotherClass.a:I

   6:      new #7; //class AnotherClass

   9:      dup

   10:    invokespecial #8; //Method AnotherClass."<init>":()V

   13:    astore_1

   14:    aload_1

   15:    bipush    20

   17:    putfield   #6; //Field AnotherClass.a:I

   20:    return

 

aload_1 把存放在局部变量表中索引1位置的对象引用压入操作栈

bipush 10 把整数10压入栈

putfield #2 把成员变量a的值设置成栈中的10，#2代表2号常量项

new #3 创建AnotherClass的对象，把引用放入栈

dup 复制刚放入的引用（这时存在着两个相同的引用）

invokespecial #4 通过其中的一个引用调用AnotherClass的构造器，初始化对象，让另一个相同引用指向初始化的对象，然后前一个引用（this）弹出栈

asstore_1 把引用保存到局部变量表中的索引1位置中，然后引用弹出栈

aload_1 把局部变量表中索引1处的值压入操作栈。

bipush 20 把整数20压入栈

putfield #2 把成员变量a的值设置成栈中的10

return 执行完毕退出

 

我们继续看构造函数中的一段代码：

public HelloWorld(java.lang.String,int);

  Code:

将该（this）对象压入操作栈，对于实例方法和构造函数的局部变量表来说第一个入口总是这个“this”。因为你需要访问一些实例中的方法和变量。

   0:      aload_0 

   调用该类的超类构造函数，因为所有类都继承与Java.lang.Object。而该类(HelloWorld)没有new函数操作，所以编译器提供必要的字节码来调用这些基类构造器。

   1:      invokespecial #1; //Method java/lang/Object."<init>":()V

   将该（this）对象压入操作栈

4:    aload_0

字符串

    5:    ldc   #2; //String abc

把栈中的name的值置为栈中的”abc”

   7:      putfield   #3; //Field name:Ljava/lang/String;

   同样，将this压入栈

   10:    aload_0

   将0压入栈。

   11:    iconst_0

   将idNumber置为栈中的0，就是上一句指令中的操作

   12:    putfield   #4; //Field idNumber:I

   将this压入栈

   15:    aload_0

   将位于局部变量表中位置1处的方法的形参strName压入栈

   16:    aload_1

   将name的值置为栈中的strName

   17:    putfield   #3; //Field name:Ljava/lang/String;

   将this压入栈，this总是位于局部变量表的index0处！

   20:    aload_0

   将位于局部变量表中位置2处的方法形参num压入栈

   21:    iload_2

   同17号操作，赋值

   22:    putfield   #4; //Field idNumber:I

   将this压入操作栈

   25:    aload_0

   将strName压入栈

   26:    aload_1

将num压入栈

   27:    iload_2

   调用方法StoreData

   28:    invokevirtual  #5; //Method StoreData:(Ljava/lang/String;I)V

   31:    return

  如果有()V 标志方法没有参数列表

我们观察发现，在每一个opcode指令的左边的位置序号都不是连续的。０，１，４，５，７，１０……为什么？

每一个方法都有一个对应得ByteCode序列，这些值对应着每一个opcode和其参数存放的序列中的某一个索引值。为什么这些索引不是顺序的？既然每一个指令占据一个字节，那索引为什么不是0，1，2呢？原因是：一些指令的参数占据了一些bytecode数组空间。比如：

Aload_0指令没有参数，所以占有一个字节，第二个指令invokespecial，由于它本身带有参数，结果它本身和参数分别就占据了一个位置，所以，上面的１过了就不是４。

 

Aload_0

invokespecial

00

05

return

Java字节码运行解析

转自:http://it.deepinmind.com/jvm/2014/04/03/java-code-to-byte-code.html

明白Java代码是如何编译成字节码并在JVM上运行的非常重要，这有助于理解程序运行的时候到底发生了些什么。理解这点不仅能搞清语言特性是如何实现的，并且在做方案讨论的时候能知道相应的副作用及权衡利弊。

本文介绍了Java代码是如何编译成字节码并在JVM上执行的。想了解JVM的内部结构以及字节码运行时用到的各个内存区域，可以看下我前面的一篇关于JVM内部细节的文章。

本文分为三部分，每一部分都分成几个小节。每个小节都可以单独阅读，不过由于一些概念是逐步建立起来的，如果你依次阅读完所有章节会更简单一些。每一节都会覆盖到Java代码中的不同结构，并详细介绍了它们是如何编译成字节码并执行的。

1. 第一部分， 基础概念

变量

局部变量

JVM是一个基于栈的架构。方法执行的时候（包括main方法），在栈上会分配一个新的帧，这个栈帧包含一组局部变量。这组局部变量包含了方法运行过程中用到的所有变量，包括this引用，所有的方法参数，以及其它局部定义的变量。对于类方法（也就是static方法）来说，方法参数是从第0个位置开始的，而对于实例方法来说，第0个位置上的变量是this指针。

局部变量可以是以下这些类型：

• char
• long
• short
• int
• float
• double
• 引用
• 返回地址

除了long和double类型外，每个变量都只占局部变量区中的一个变量槽(slot)，而long及double会占用两个连续的变量槽，因为这些类型是64位的。

当一个新的变量创建的时候，操作数栈（operand stack）会用来存储这个新变量的值。然后这个变量会存储到局部变量区中对应的位置上。如果这个变量不是基础类型的话，本地变量槽上存的就只是一个引用。这个引用指向堆的里一个对象。

比如：

int i = 5;

编译后就成了

0: bipush      5
2: istore_0

bipush	用来将一个字节作为整型数字压入操作数栈中，在这里5就会被压入操作数栈上。
istore_0	这是istore_这组指令集（译注：严格来说，这个应该叫做操作码，opcode ,指令是指操作码加上对应的操作数，oprand。不过操作码一般作为指令的助记符，这里统称为指令）中的一条，这组指令是将一个整型存储到本地变量中。代表的是局部变量区中的位置，并且只能是0,1,2,3。再高的话只能用另一条指令istore了，这条指令会接受一个操作数，对应的是局部变量区中的位置信息。

当这条指令执行的时候，内存布局是这样的：

class文件中的每一个方法都会包含一个局部变量表，如果这段代码在一个方法里面的话，你在类文件的局部变量表中会找到如下的一条记录。

LocalVariableTable:
        Start  Length  Slot  Name   Signature
          0      1      1     i         I

字段

Java类里面的字段是作为类对象实例的一部分，存储在堆里面的（类变量对应存储在类对象里面）。关于字段的信息会添加到类文件里的field_info数组里，像下面这样：

ClassFile {
    u4 magic;
    u2 minor_version;
    u2 major_version;
    u2 constant_pool_count;
    cp_info contant_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];
}

另外，如果变量被初始化了，那么初始化的字节码会加到构造方法里。

下面这段代码编译了之后：

public class SimpleClass {

    public int simpleField = 100;

}

如果你用javap进行反编译，这个被添加到了field_info数组里的字段会多出一段描述信息。

public int simpleField;
    Signature: I
    flags: ACC_PUBLIC

初始化变量的字节码会被加到构造方法里，像下面这样：

public SimpleClass();
  Signature: ()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: bipush        100
       7: putfield      #2                  // Field simpleField:I
      10: return

aload_0	从局部变量数组中加载一个对象引用到操作数栈的栈顶。尽管这段代码看起来没有构造方法，但是在编译器生成的默认的构造方法里，就会包含这段初始化的代码。第一个局部变量正好是this引用，于是aload_0把this引用压到操作数栈中。aload_0是aload_指令集中的一条，这组指令会将引用加载到操作数栈中。n对应的是局部变量数组中的位置，并且也只能是0,1,2,3。还有类似的加载指令，它们加载的并不是对象引用，比如iload_,lload_,fload_,和dload_, 这里i代表int,l代表long,f代表float,d代表double。局部变量的在数组中的位置大于3的，得通过iload,lload,fload,dload,和aload进行加载，这些指令都接受一个操作数，它代表的是要加载的局部变量的在数组中的位置。
invokespecial	这条指令可以用来调用对象实例的初始化方法，私有方法和父类中的方法。它是方法调用指令集中的一条，其它的还有invokedynamic, invokeinterface, invokespecial, invokestatic, invokevirtual.这里的invokespecial 指令调用的是父类也就是java.lang.Objectr构造方法。
bipush	它是用来把一个字节作为整型压到操作数栈中的，在这里100会被加到操作栈里面。
putfield	它接受一个操作数，这个数引用的是运行时常量池里的一个字段，在这里这个字段是simpleField。赋给这个字段的值，以及包含这个字段的对象引用，在执行这条指令的时候，都 会从操作数栈顶上pop出来。前面的aload_0指令已经把包含这个字段的对象压到操作数栈上了，而后面的bipush又把100压到栈里。最后putfield指令会将这两个值从栈顶弹出。执行完的结果就是这个对象的simpleField这个字段的值更新成了100。

上述代码执行的时候内存里面是这样的：

这里的putfield指令的操作数引用的是常量池里的第二个位置。JVM会为每种类型维护一个常量池，运行时的数据结构有点类似一个符号表，尽管它包含的信息更多。Java中的字节码操作需要数据，但通常这些数据都太大了，存储在字节码里不适合，它们会被存储在常量池里面，而字节码包含一个常量池里的引用 。当类文件生成的时候，其中的一块就是常量池：

Constant pool:
   #1 = Methodref          #4.#16         //  java/lang/Object."<init>":()V
   #2 = Fieldref           #3.#17         //  SimpleClass.simpleField:I
   #3 = Class              #13            //  SimpleClass
   #4 = Class              #19            //  java/lang/Object
   #5 = Utf8               simpleField
   #6 = Utf8               I
   #7 = Utf8               <init>
   #8 = Utf8               ()V
   #9 = Utf8               Code
  #10 = Utf8               LineNumberTable
  #11 = Utf8               LocalVariableTable
  #12 = Utf8               this
  #13 = Utf8               SimpleClass
  #14 = Utf8               SourceFile
  #15 = Utf8               SimpleClass.java
  #16 = NameAndType        #7:#8          //  "<init>":()V
  #17 = NameAndType        #5:#6          //  simpleField:I
  #18 = Utf8               LSimpleClass;
  #19 = Utf8               java/lang/Object

常量字段（类常量）

带有final标记的常量字段在class文件里会被标记成ACC_FINAL.

比如

public class SimpleClass {

    public final int simpleField = 100;

}

字段的描述信息会标记成ACC_FINAL:

public static final int simpleField = 100;
    Signature: I
    flags: ACC_PUBLIC, ACC_FINAL
    ConstantValue: int 100

对应的初始化代码并不变：

4: aload_0
5: bipush        100
7: putfield      #2                  // Field simpleField:I

静态变量

带有static修饰符的静态变量则会被标记成ACC_STATIC：

public static int simpleField;
    Signature: I
    flags: ACC_PUBLIC, ACC_STATIC

不过在实例的构造方法中却再也找 不到对应的初始化代码了。因为static变量会在类的构造方法 中进行初始化，并且它用的是putstatic指令而不是putfiled。

static {};
  Signature: ()V
  flags: ACC_STATIC
  Code:
    stack=1, locals=0, args_size=0
       0: bipush         100
       2: putstatic      #2                  // Field simpleField:I
       5: return