java程序的加载过程

1. public class StaticTest {  
2.     public static int k=0;  
3.     public static StaticTest s1=new StaticTest("s1");  
4.     public static StaticTest s2=new StaticTest("s2");  
5.     public static int i=print("i");  
6.     public static int n=99;  
7.     public int j=print("j");  
8.       
9.     {  
10.         print("构造块");  
11.     }  
12.       
13.     static  
14.     {  
15.         print("静态块");  
16.     }  
17.       
18.     public static int print(String s)  
19.     {  
20.         System.out.println(++k+":"+s+"\ti="+i+"\tn="+n);  
21.         ++n;  
22.         return ++i;  
23.     }  
24.       
25.     public StaticTest(String s)  
26.     {  
27.         System.out.println(++k+":"+s+"\ti="+i+"\tn="+n);  
28.         ++i;  
29.         ++n;  
30.     }  
31.   
32.     public static void main(String[] args) {  
33.         new StaticTest("init");  
34.     }  
35. }  

首先给出代码输出：

[plain] view plain copy print ?

1. 1:j i=0 n=0  
2. 2:构造块   i=1 n=1  
3. 3:s1    i=2 n=2  
4. 4:j i=3 n=3  
5. 5:构造块   i=4 n=4  
6. 6:s2    i=5 n=5  
7. 7:i i=6 n=6  
8. 8:静态块   i=7 n=99  
9. 9:j i=8 n=100  
10. 10:构造块  i=9 n=101  
11. 11:init i=10    n=102  

没想到只是创建了一个对象，居然执行了这么多语句！下面我们逐条分析每条输出语句。

首先我们需要对java程序的加载过程有个大概的了解：第一执行类中的静态代码，包括静态成员变量的初始化和静态语句块的执行；第二执行类中的非静态代码，包括非静态成员变量的初始化和非静态语句块的执行，最后执行构造函数。在继承的情况下，会首先执行父类的静态代码，然后执行子类的静态代码；之后执行父类的非静态代码和构造函数；最后执行子类的非静态代码和构造函数。用图表示如下：

第一条语句打印的是j相关的内容，所以执行了第7行代码。很明显该行代码执行的是非静态变量的赋值操作，这似乎不符合上述java程序加载规则。我们按照前述规则执行一下代码，首先会执行静态变量k的赋值，然后创建该类的一个静态实例。这时我们就会发现，第一条打印语句可能和该类的这个静态实例对象有关。我们尝试着创建这个静态实例，这时的程序加载过程又变为上述标准的加载过程：首先执行静态代码，然后非静态，最后构造函数。由于静态代码的执行是按代码的先后顺序进行，所以创建该静态实例时只有第一个静态变量k会赋值，后面的静态变量和静态语句块还都不存在；之后执行非静态代码，第一句非静态代码即是代码第7行的变量j赋值。这就解释了为什么第一条打印语句会是第7行的代码。同时这也解释了第二和第三条打印，第二条打印语句执行非静态代码，执行之后就调用构造函数创建实例对象s1。

同理，第4到6条打印语句是在创建静态实例对象s2时执行的。

在完成两个静态实例对象的创建后，下面要执行静态变量i的赋值，这就是第7条打印语句。后面还会对静态成员变量n赋值。之后是执行静态语句块，打印第8行语句。执行完静态代码部分后，接下来要执行非静态代码部分，按照写代码的前后顺序先为j赋值，然后执行非静态语句块，这就是第9和10行的打印语句。在执行完上面的所有步骤之后，开始执行类的构造函数创建对象，这就是第11行打印语句。

通过上面的分析我们发现：上述代码的执行顺序依旧符合一开始说明的java程序加载过程。只是由于有两个该类的静态实例变量，导致打印语句的复杂化。在这种情况下，打印过程类似于一个递归，每一次递归都按照标准的加载过程执行。

该代码一开始给人很多疑问，感觉运行过程中会抛出各种异常，但是代码却神奇地打印出了11条语句，的确让人吃惊。第一个疑问是该类内部有一个该类自身的静态对象，是否会导致循环递归。大家可以尝试一下，将代码第3或4行的static去掉，然后运行程序，就会提示StackOverflowError异常。为啥静态对象不会导致栈溢出，而非静态对象就会溢出？这是因为静态成员变量属于类所有，所有的类对象共享该静态成员变量，也即该静态成员变量只有一份，所以在递归的过程中，当发现正在创建该静态变量时，系统不会再去创建该变量，所以不会递归。但是如果是非静态对象，在递归的过程中，每次遇到该new语句都会再次创建一个新的对象，导致栈溢出。

该代码中另一个疑问是变量i的初值。在静态函数print中会打印i的值，但是在打印的时候变量i可能还没有定义（前6行打印语句都没有定义变量i）。程序居然也给通过了，这说明静态变量的声明会在初始化之前完成，并赋初值0。

类加载的顺序：
1.加载静态成员/代码块：
先递归地加载父类的静态成员/代码块(Object的最先)；再依次加载到本类的静态成员。
同一个类里的静态成员/代码块，按写代码的顺序加载。
如果其间调用静态方法，则调用时会先运行静态方法，再继续加载。同一个类里调用静态方法时，可以不理会写代码的顺序。
调用父类的静态成员，可以像调用自己的一样；但调用其子类的静态成员，必须使用“子类名.成员名”来调用。
2.加载非静态成员/代码块：（实例块在创建对象时才会被加载。而静态成员在不创建对象时可以加载）
先递归地加载父类的非静态成员/代码块(Object的最先)；再依次加载到本类的非静态成员。
同一个类里的非静态成员/代码块，按写代码的顺序加载。同一个类里调用方法时，可以不理会写代码的顺序。
但调用属性时，必须注意加载顺序。一般编译不通过，如果能在加载前调用，值为默认初始值(如：null 或者 0)。
调用父类的非静态成员(private 除外)，也可以像调用自己的一样。
3.调用构造方法：
先递归地调用父类的构造方法(Object的最先)；默认调用父类空参的，也可在第一行写明调用父类某个带参的。
再依次到本类的构造方法；构造方法内，也可在第一行写明调用某个本类其它的构造方法。
注意：如果加载时遇到 override 的成员，可看作是所需创建的类型赋值给当前类型。
其调用按多态用法：只有非静态方法有多态；而静态方法、静态属性、非静态属性都没有多态。
假设子类override父类的所有成员，包括静态成员、非静态属性和非静态方法。
由于构造子类时会先构造父类；而构造父类时，其所用的静态成员和非静态属性是父类的，但非静态方法却是子类的；
由于构造父类时，子类并未加载；如果此时所调用的非静态方法里有成员，则这个成员是子类的，且非静态属性是默认初始值的。