深入Java初始化

　　关于Java 初始化，有多文章都用了很大篇幅的介绍。经典的<>更是用了专门的一章来介绍Java初始化。但在大量有代码实例后面，感觉上仍然没有真正深入到初始化的本质。

　　本文以作者对JVM的理解和自己的经验，对Java的初始化做一个比深入的说明，由于作者有水平限制，以及JDK各实现版本的变化，可能仍然有不少错误和缺点。欢迎行家高手赐教。

　　要深入了解Java初始化，我们无法知道从程序流程上知道JVM是按什么顺序来执行的。了解JVM的执行机制和堆栈跟踪是有效的手段。可惜的是，到目前为止。JDK1。4和JDK1。5在javap功能上却仍然存在着BUG。所以有些过程我无法用实际的结果向你证明两种相反的情况。

　　<>(第三版)在第四章一开始的时候,这样来描述Java的初始化工作:

　　以下译文原文:

　　可以这样认为,每个类都有一个名为Initialize()的方法,这个名字就暗示了它得在使用之前调用,不幸的是,这么做的话,用户就得记住要调用这个方法,java类库的设计者们可以通过一种被称为构造函数的特殊方法,来保证每个对象都能得到被始化.如果类有构造函数,那么java就会在对象刚刚创建,用户还来不及得到的时候,自动调用那个构造函数,这样初始化就有保障了。

　　我不知道原作者的描述和译者的理解之间有多大的差异,结合全章,我没有发现两个最关键的字""和""。至少说明原作者和译者并没有真正说明JVM在初始化时做了什么,或者说并不了解JVM的初始化内幕,要不然明明有这两个方法,却为什么要认为有一个事实上并不存在的"Initialize()"方法呢?

　　""和""方法在哪里？这两个方法是实际存在而你又找不到的方法，也许正是这样才使得一些大师都犯晕。加上jdk实现上的一些BUG，如果没有深入了解，真的让人摸不着北。

　　现在科学体系有一个奇怪的现象，那么庞大的体系最初都是建立在一个假设的基础是，假设1是正确的，由此推导出2，再继续推导出10000000000。可惜的是太多的人根本不在乎2-100000000000这样的体系都是建立在假设1是正确的基础上的。我并不会用“可以这样认为”这样的假设，我要确实证明""和""方法是真真实实的存在的：

 package debug;public class MyTest{static int i = 100/0;public static void main(String[] args){Ssytem.out.println("Hello,World!");}}

　　执行一下看看,这是jdk1.5的输出：

java.lang.ExceptionInInitializerErrorCaused by: java.lang.ArithmeticException: / by zeroat debug.MyTest.(Test.java:3)Exception in thread "main"

　　请注意，和其它方法调用时产生的异常一样，异常被定位于debug.MyTest的.

　　再来看：

package debug;public class Test {Test(){int i = 100 / 0;}public static void main(String[] args) {new Test();}}

　　jdk1.5输入：

  Exception in thread "main" java.lang.ArithmeticException: / by zeroat debug.Test.(Test.java:4)at debug.Test.main(Test.java:7)

　　JVM并没有把异常定位在Test()构造方法中，而是在debug.Test.。

　　当我们看到了这两个方法以后，我们再来详细讨论这两个“内置初始化方法”（我并不喜欢生造一些

　　非标准的术语，但我确实不知道如何规范地称呼他们）。

　　内置初始化方法是JVM在内部专门用于初始化的特有方法，而不是提供给程序员调用的方法，事实上“<>”这样的语法在源程序中你连编译都无法通过。这就说明，初始化是由JVM控制而不是让程序员来控制的。

类初始化方法：

　　我没有从任何地方了解到的cl是不是class的简写，但这个方法确实是用来对“类”进行初

　　始化的。换句话说它是用来初始化static上下文的。

　　在类装载（load）时，JVM会调用内置的方法对类成员和静态初始化块进行初始化调用。它们的顺序按照源文件的原文顺序。

　　我们稍微增加两行static语句：

package debug;public class Test {static int x = 0;static String s = "123";static {String s1 = "456";if(1==1)throw new RuntimeException();}public static void main(String[] args) {new Test();}}

　　然后进行反编译：

javap -c debug.TestCompiled from "Test.java"public class debug.Test extends java.lang.Object{static int x;static java.lang.String s;public debug.Test();Code:0:   aload_01:   invokespecial   #1; //Method java/lang/Object."":()V4:   returnpublic static void main(java.lang.String[]);Code:0:   new     #2; //class debug/Test3:   dup4:   invokespecial   #3; //Method "":()V7:   pop8:   returnstatic {};Code:0:   iconst_01:   putstatic       #4; //Field x:I4:   ldc     #5; //String 1236:   putstatic       #6; //Field s:Ljava/lang/String;9:   ldc     #7; //String 45611:  astore_012:  new     #8; //class java/lang/RuntimeException15:  dup16:  invokespecial   #9; //Method java/lang/RuntimeException."":()V19:  athrow}

　　我们可以看到,类初始化正是按照源文件中定义的原文顺序进行。先是声明

  static  int x;static  java.lang.String s;

　　然后对int x和String s进行赋值：

   0:   iconst_01:   putstatic       #4; //Field x:I4:   ldc     #5; //String 1236:   putstatic       #6; //Field s:Ljava/lang/String;

　　执行初始化块的String s1 = "456";生成一个RuntimeException抛

   9:   ldc     #7; //String 45611:  astore_012:  new     #8; //class java/lang/RuntimeException15:  dup16:  invokespecial   #9; //Method java/lang/RuntimeException."":()V19:  athrow

　　要明白的是，""方法不仅是类初始化方法，而且也是接口初始化方法。并不是所以接口

　　的属性都是内联的，只有直接赋常量值的接口常量才会内联。而

　　[public static final] double d = Math.random()*100;

　　这样的表达式是需要计算的，在接口中就要由""方法来初始化。

下面我们再来看看实例初始化方法""

　　""用于对象创建时对对象进行初始化，当在HEAP中创建对象时，一旦在HEAP分配了空间。最先就会调用""方法。这个方法包括实例变量的赋值（声明不在其中）和初始化块，以及构造方法调用。如果有多个重载的构造方法，每个构造方法都会有一个对应的""方法。构造方法隐式或显示调用父类的构造方法前,总是先执行实例变量初始化和初始化块.同样，实例变量和初始化块的顺序也是按源文件的原文顺序执行，构造方法中的代码在最后执行：

package debug;public class Test {int x = 0;String s = "123";{String s1 = "456";//if(1==1)//throw new RuntimeException();}public Test(){String ss = "789";}public static void main(String[] args) {new Test();}}javap -c debug.Test的结果：Compiled from "Test.java"public class debug.Test extends java.lang.Object{int x;java.lang.String s;public debug.Test();Code:0:   aload_01:   invokespecial   #1; //Method java/lang/Object."":()V4:   aload_05:   iconst_06:   putfield        #2; //Field x:I9:   aload_010:  ldc     #3; //String 12312:  putfield        #4; //Field s:Ljava/lang/String;15:  ldc     #5; //String 45617:  astore_118:  ldc     #6; //String 78920:  astore_121:  returnpublic static void main(java.lang.String[]);Code:0:   new     #7; //class debug/Test3:   dup4:   invokespecial   #8; //Method "":()V7:   pop8:   return}

　　如果在同一个类中，一个构造方法调用了另一个构造方法，那么对应的""方法就会调用另一

　　个""，但是实例变量和初始化块会被忽略，否则它们就会被多次执行。

package debug;public class Test {String s1 = rt("s1");String s2 = "s2";public Test(){s1 = "s1";}public Test(String s){this();if(1==1) throw new Runtime();}String rt(String s){return s;}public static void main(String[] args) {new Test("");}}

　　反编译的结果：

Compiled from "Test.java"public class debug.Test extends java.lang.Object{java.lang.String s1;java.lang.String s2;public debug.Test();Code:0:   aload_01:   invokespecial   #1; //Method java/lang/Object."":()V4:   aload_05:   aload_06:   ldc     #2; //String s18:   invokevirtual   #3; //Method rt:(Ljava/lang/String;)Ljava/lang/String;11:  putfield        #4; //Field s1:Ljava/lang/String;14:  aload_015:  ldc     #5; //String s217:  putfield        #6; //Field s2:Ljava/lang/String;20:  aload_021:  ldc     #2; //String s123:  putfield        #4; //Field s1:Ljava/lang/String;26:  returnpublic debug.Test(java.lang.String);Code:0:   aload_01:   invokespecial   #7; //Method "":()V4:   new     #8; //class java/lang/RuntimeException7:   dup8:   invokespecial   #9; //Method java/lang/RuntimeException."":()V11:  athrowjava.lang.String rt(java.lang.String);Code:0:   aload_11:   areturnpublic static void main(java.lang.String[]);Code:0:   new     #10; //class debug/Test3:   dup4:   ldc     #11; //String6:   invokespecial   #12; //Method "":(Ljava/lang/String;)V9:   pop10:  return}

　　我们看到，由于Test(String s)调用了Test();所以"":(Ljava/lang/String;)V不再对

　　实例变量和初始化块进次初始化：

public debug.Test(java.lang.String);Code:0:   aload_01:   invokespecial   #7; //Method "":()V4:   new     #8; //class java/lang/RuntimeException7:   dup8:   invokespecial   #9; //Method java/lang/RuntimeException."":()V11:  athrow

　　而如果两个构造方法是相互独立的，则每个构造方法调用前都会执行实例变量和初始化块的调用：

package debug;public class Test {String s1 = rt("s1");String s2 = "s2";{String s3 = "s3";}public Test() {s1 = "s1";}public Test(String s) {if (1 == 1)throw new RuntimeException();}String rt(String s) {return s;}public static void main(String[] args) {new Test("");}}

　　反编译的结果：

Compiled from "Test.java"public class debug.Test extends java.lang.Object{java.lang.String s1;java.lang.String s2;public debug.Test();Code:0:   aload_01:   invokespecial   #1; //Method java/lang/Object."":()V4:   aload_05:   aload_06:   ldc     #2; //String s18:   invokevirtual   #3; //Method rt:(Ljava/lang/String;)Ljava/lang/String;11:  putfield        #4; //Field s1:Ljava/lang/String;14:  aload_015:  ldc     #5; //String s217:  putfield        #6; //Field s2:Ljava/lang/String;20:  ldc     #7; //String s322:  astore_123:  aload_024:  ldc     #2; //String s126:  putfield        #4; //Field s1:Ljava/lang/String;29:  returnpublic debug.Test(java.lang.String);Code:0:   aload_01:   invokespecial   #1; //Method java/lang/Object."":()V4:   aload_05:   aload_06:   ldc     #2; //String s18:   invokevirtual   #3; //Method rt:(Ljava/lang/String;)Ljava/lang/String;11:  putfield        #4; //Field s1:Ljava/lang/String;14:  aload_015:  ldc     #5; //String s217:  putfield        #6; //Field s2:Ljava/lang/String;20:  ldc     #7; //String s322:  astore_223:  new     #8; //class java/lang/RuntimeException26:  dup27:  invokespecial   #9; //Method java/lang/RuntimeException."":()V30:  athrowjava.lang.String rt(java.lang.String);Code:0:   aload_11:   areturnpublic static void main(java.lang.String[]);Code:0:   new     #10; //class debug/Test3:   dup4:   ldc     #11; //String6:   invokespecial   #12; //Method "":(Ljava/lang/String;)V9:   pop10:  return}

　　明白了上面这些知识,我们来做一个小测试吧:

public class Test2 extends Test1{{System.out.print("1");}Test2(){System.out.print("2");}static{System.out.print("3");}{System.out.print("4");}public static void main(String[] args) {new Test2();}}class Test1 {Test1(){System.out.print("5");}static{System.out.print("6");}}

　　试试看能清楚打印的顺序吗?如果没有new Test2()将打印什么?

个人自述

一个男人.
一个写程序的男人.
一个写程序并正在从程序中寻找快乐的男人.
一个写程序并正在从程序中寻找快乐并把快乐传递给大家的男人.

一个书生.
一个寂寞的书生.
一个寂寞的梅香竹影下敲声写韵的书生.
一个寂寞的梅香竹影下敲声写韵晨钟暮鼓中逸气扬剑的书生.

那个男人是位书生。没有人知道他的姓名，居无定所，行无定踪，亦耕变读，或渔或樵。
所以有人叫他樵夫(Axman)，有人叫他渔郎(fisher)。

Dev2Dev资深网友，Dev2Dev ID:axman。个人Blog：http://blog.csdn.net/axman/