类的初始化与实例化

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

分析：

类的生命周期包括：加载、验证、准备、解析、初始化、使用、卸载。

该类首先被加载，然后经过验证，进入准备阶段，

在准备阶段时：

在方法区为静态成员分配内存空间，并设置初始值：k=0，t1=null，t2=null，i=0，n=0，j=0。

在初始化阶段时：

会按照类文件中的代码顺序初始化静态成员，从上至下

初始化k=0，

初始化t1=new StaticTest("t1")，此时会导致类的实例化。

类的实例化会在堆上分配空间，设置实例成员的值、执行构造代码块。所以先print("j");再print("构造块");  然后执行new StaticTest("t1");

1. 1:j i=0 n=0  
2. 2:构造块 i=1 n=1  
3. 3:t1 i=2 n=2 

初始化t2=new StaticTest("t2")，此时会导致类的实例化。

类的实例化会在堆上分配空间，设置实例成员的值、执行构造代码块。所以先print("j");再print("构造块");  然后执行new StaticTest("t2");

1. 4:j i=3 n=3  
2. 5:构造块 i=4 n=4  
3. 6:t2 i=5 n=5

初始化i = print("i");

1. 7:i i=6 n=6  

初始化n=99；

执行静态块print("静态块");

8:静态块 i=7 n=99 

此时，初始化完毕，再执行new StaticTest("init");  

1. 9:j i=8 n=100  
2. 10:构造块 i=9 n=101  
3. 11:init i=10 n=102

------------------

输出为：

1. 1:j i=0 n=0  
2. 2:构造块 i=1 n=1  
3. 3:t1 i=2 n=2  
4. 4:j i=3 n=3  
5. 5:构造块 i=4 n=4  
6. 6:t2 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