可以这样认为，每个类都有一个名为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.exceptionininitializererror caused by: java.lang.arithmeticexception: / by zero at 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 zero

　　at 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.test compiled 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_0 　　1: invokespecial #1; //method java/lang/object."":()v 　　4: return 　　public static void main(java.lang.string[]); 　　code: 　　0: new #2; //class debug/test 　　3: dup 　　4: invokespecial #3; //method "":()v 　　7: pop 　　8: return 　　static {}; 　　code: 　　0: iconst_0 　　1: putstatic #4; //field x:i 　　4: ldc #5; //string 123 　　6: putstatic #6; //field s:ljava/lang/string; 　　9: ldc #7; //string 456 　　11: astore_0 　　12: new #8; //class java/lang/runtimeexception 　　15: dup 　　16: invokespecial #9; //method java/lang/runtimeexception."":()v 　　19: athrow 　}

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

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

　　然后对int x和string s进行赋值:

0: iconst_0 1: putstatic #4; //field x:i 4: ldc #5; //string 123 6: putstatic #6; //field s:ljava/lang/string;

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

9: ldc #7; //string 456 11: astore_0 12: new #8; //class java/lang/runtimeexception 15: dup 16: invokespecial #9; //method java/lang/runtimeexception."":()v 19: 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_0 　　1: invokespecial #1; //method java/lang/object."":()v 　　4: aload_0 　　5: iconst_0 　　6: putfield #2; //field x:i 　　9: aload_0 　　10: ldc #3; //string 123 　　12: putfield #4; //field s:ljava/lang/string; 　　15: ldc #5; //string 456 　　17: astore_1 　　18: ldc #6; //string 789 　　20: astore_1 　　21: return 　　public static void main(java.lang.string[]); 　　code: 　　0: new #7; //class debug/test 　　3: dup 　　4: invokespecial #8; //method "":()v 　　7: pop 　　8: 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_0 　1: invokespecial #1; //method java/lang/object."":()v 　4: aload_0 　5: aload_0 　6: ldc #2; //string s1 　8: invokevirtual #3; //method rt:(ljava/lang/string;)ljava/lang/string; 　11: putfield #4; //field s1:ljava/lang/string; 　14: aload_0 　15: ldc #5; //string s2 　17: putfield #6; //field s2:ljava/lang/string; 　20: aload_0 　21: ldc #2; //string s1 　23: putfield #4; //field s1:ljava/lang/string; 　26: return 　public debug.test(java.lang.string); 　code: 　　0: aload_0 　　1: invokespecial #7; //method "":()v 　　4: new #8; //class java/lang/runtimeexception 　　7: dup 　　8: invokespecial #9; //method java/lang/runtimeexception."":()v 　　11: athrow 　　java.lang.string rt(java.lang.string); 　code: 　　0: aload_1 　　1: areturn 　　public static void main(java.lang.string[]); 　code: 　　0: new #10; //class debug/test 　　3: dup 　　4: ldc #11; //string 　　6: invokespecial #12; //method "":(ljava/lang/string;)v 　　9: pop 　　10: return 　}

　　我们看到，由于test(string s)调用了test();所以"":(ljava/lang/string;)v不再对实例变量和初始化块进次初始化:

public debug.test(java.lang.string); code: 　0: aload_0 　1: invokespecial #7; //method "":()v 　4: new #8; //class java/lang/runtimeexception 　7: dup 　8: invokespecial #9; //method java/lang/runtimeexception."":()v 　11: 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_0 　　1: invokespecial #1; //method java/lang/object."":()v 　　4: aload_0 　　5: aload_0 　　6: ldc #2; //string s1 　　8: invokevirtual #3; //method rt:(ljava/lang/string;)ljava/lang/string; 　　11: putfield #4; //field s1:ljava/lang/string; 　　14: aload_0 　　15: ldc #5; //string s2 　　17: putfield #6; //field s2:ljava/lang/string; 　　20: ldc #7; //string s3 　　22: astore_1 　　23: aload_0 　　24: ldc #2; //string s1 　　26: putfield #4; //field s1:ljava/lang/string; 　　29: return 　　public debug.test(java.lang.string); 　　code: 　　0: aload_0 　　1: invokespecial #1; //method java/lang/object."":()v 　　4: aload_0 　　5: aload_0 　　6: ldc #2; //string s1 　　8: invokevirtual #3; //method rt:(ljava/lang/string;)ljava/lang/string; 　　11: putfield #4; //field s1:ljava/lang/string; 　　14: aload_0 　　15: ldc #5; //string s2 　　17: putfield #6; //field s2:ljava/lang/string; 　　20: ldc #7; //string s3 　　22: astore_2 　　23: new #8; //class java/lang/runtimeexception 　　26: dup 　　27: invokespecial #9; //method java/lang/runtimeexception."":()v 　　30: athrow 　　java.lang.string rt(java.lang.string); 　　code: 　　0: aload_1 　　1: areturn 　　public static void main(java.lang.string[]); 　　code: 　　0: new #10; //class debug/test 　　3: dup 　　4: ldc #11; //string 　　6: invokespecial #12; //method "":(ljava/lang/string;)v 　　9: pop 　　10: 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()将打印什么?