转自:http://www.linuxdiyf.com/viewarticle.php?id=18987
可以这样认为,每个类都有一个名为Initialize()的方法,这个名字就暗示了它得在使用之前调用,不幸的是,这么做的话,用户就得记住要调用这个方法,java类库的设计者们可以通过一种被称为构造函数的特殊方法,来保证每个对象都能得到被始化.如果类有构造函数,那么java就会在对象刚刚创建,用户还来不及得到的时候,自动调用那个构造函数,这样初始化就有保障了。
我不知道原作者的描述和译者的理解之间有多大的差异,结合全章,我没有发现两个最关键的字""和""。至少说明原作者和译者并没有真正说明JVM在初始化时做了什么,或者说并不了解JVM的初始化内幕,要不然明明有这两个方法,却为什么要认为有一个事实上并不存在的"Initialize()"方法呢?
""和""方法在哪里?这两个方法是实际存在而你又找不到的方法,也许正是这样才使得一些大师都犯晕。加上jdk实现上的一些BUG,如果没有深入了解,真的让人摸不着北。
现在科学体系有一个奇怪的现象,那么庞大的体系最初都是建立在一个假设的基础是,假设1是正确的,由此推导出2,再继续推导出10000000000。可惜的是太多的人根本不在乎2-100000000000这样的体系都是建立在假设1是正确的基础上的。我并不会用“可以这样认为”这样的假设,我要确实证明""和""方法是真真实实的存在的:
CODE:
package debug;
public class MyTest{ static int i = 100/0; public static void main(String[] args){ Ssytem.out.println("Hello,World!"); } } |
执行一下看看,这是jdk1.5的输出:
CODE:
java.lang.ExceptionInInitializerError
Caused by: java.lang.ArithmeticException: / by zero at debug.MyTest.(Test.java:3) Exception in thread "main" |
请注意,和其它方法调用时产生的异常一样,异常被定位于debug.MyTest的.
再来看:
CODE:
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语句:
CODE:
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(); } } |
然后进行反编译:
CODE:
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 } |
我们可以看到,类初始化正是按照源文件中定义的原文顺序进行。先是声明
CODE:
static int x;
static java.lang.String s; |
然后对int x和String s进行赋值:
CODE:
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抛
CODE:
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分配了空间。最先就会调用""方法。这个方法包括实例变量的赋值(声明不在其中)和初始化块,以及构造方法调用。如果有多个重载的构造方法,每个构造方法都会有一个对应的""方法。构造方法隐式或显示调用父类的构造方法前,总是先执行实例变量初始化和初始化块.同样,实例变量和初始化块的顺序也是按源文件的原文顺序执行,构造方法中的代码在最后执行:
CODE:
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 } |
如果在同一个类中,一个构造方法调用了另一个构造方法,那么对应的""方法就会调用另一个"",但是实例变量和初始化块会被忽略,否则它们就会被多次执行。
CODE:
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(""); } } |
反编译的结果:
CODE:
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不再对实例变量和初始化块进次初始化:
CODE:
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 |
而如果两个构造方法是相互独立的,则每个构造方法调用前都会执行实例变量和初始化块的调用:
CODE:
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(""); } } |
反编译的结果:
CODE:
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 } |
明白了上面这些知识,我们来做一个小测试吧:
CODE:
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()将打印什么?