類的加載機制，複習一下

本文根據《深刻理解java虛擬機》第7章部份內容整理

    Java虛擬機把描述類的數據從Class文件加載到內存，並對數據進行校驗、轉換解析和初始化，最終造成能夠被虛擬機直接使用的Java類型，這就是虛擬機的加載機制。

   類從被加載到虛擬機內存中開始，到卸載出內存爲止，它的整個生命週期包括了：加載（Loading）、驗證（Verification）、準備（Preparation）、解析（Resolution）、初始化（Initialization）、使用（using）、和卸載（Unloading）七個階段。其中驗證、準備和解析三個部分統稱爲鏈接（Linking），這七個階段的發生順序以下圖所示：

    如上圖所示，加載、驗證、準備、初始化和卸載這五個階段的順序是肯定的，類的加載過程必須按照這個順序來循序漸進地開始，而解析階段則不必定，它在某些狀況下能夠在初始化階段後再開始。

    類的生命週期的每個階段一般都是互相交叉混合式進行的，一般會在一個階段執行的過程當中調用或激活另一個階段。

    Java虛擬機規範沒有強制性約束在何時開始類加載過程，可是對於初始化階段，虛擬機規範則嚴格規定了有且只有四種狀況必需當即對類進行「初始化」（而加載、驗證、準備階段則必需在此以前開始），這四種狀況歸類以下：

    1.遇到new、getstatic、putstatic或invokestatic這4條字節碼指令時，若是類沒有進行過初始化，則須要先觸發其初始化。生成這4條指令最多見的Java代碼場景是：使用new關鍵字實例化對象時、讀取或者設置一個類的靜態字段（被final修飾、已在編譯器把結果放入常量池的靜態字段除外）時、以及調用一個類的靜態方法的時候。

    2.使用java.lang.reflect包的方法對類進行反射調用的時候，若是類沒有進行過初始化，則須要先觸發其初始化。

    3.當初始化一個類的時候，若是發現其父類尚未進行過初始化，則須要觸發父類的初始化。

    4.當虛擬機啓動時，用戶須要指定一個執行的主類（包含main()方法的類），虛擬機會先初始化這個類。

    對於這四種觸發類進行初始化的場景，在java虛擬機規範中限定了「有且只有」這四種場景會觸發。這四種場景的行爲稱爲對類的主動引用，除此之外的全部引用類的方式都不會觸發類的初始化，稱爲被動引用。

    下面經過三個實例來講明被動引用：

示例一

父類SuperClass.java

 

Java代碼  

1. package com.chenzhou.classloading;  
2. /** 
3.  * ClassName:SuperClass <br/> 
4.  * Function: 被動使用類：經過子類引用父類的靜態字段，不會致使子類初始化. <br/> 
5.  * Date:     2012-7-18 上午09:37:06 <br/> 
6.  * @author   chenzhou 
7.  * @version   
8.  * @since    JDK 1.6 
9.  * @see       
10.  */  
11. public class SuperClass {  
12.     static{  
13.         System.out.println("SuperClass init!");  
14.     }  
15.     public static int value = 123;  
16. }  

子類SubClass.java

Java代碼  

1. package com.chenzhou.classloading;  
2.   
3. public class SubClass extends SuperClass {  
4.     static{  
5.         System.out.println("SubClass init!");  
6.     }  
7. }  

主類NotInitialization.java

Java代碼  

1. package com.chenzhou.classloading;  
2. /** 
3.  * ClassName:NotInitialization <br/> 
4.  * Function: 非主動使用類字段演示. <br/> 
5.  * Date:     2012-7-18 上午09:41:14 <br/> 
6.  * @author   chenzhou 
7.  * @version   
8.  * @since    JDK 1.6 
9.  * @see       
10.  */  
11. public class NotInitialization {  
12.     public static void main(String[] args) {  
13.         System.out.println(SubClass.value);  
14.     }  
15. }  

 輸出結果：

Txt代碼  

1. SuperClass init!  
2. 123  

 由結果能夠看出只輸出了「SuperClass init！」，沒有輸出「SubClass init！」。這是由於對於靜態字段，只有直接定義該字段的類纔會被初始化，所以當咱們經過子類來引用父類中定義的靜態字段時，只會觸發父類的初始化，而不會觸發子類的初始化。

 

 

示例二

父類SuperClass.java如上一個示例同樣

主類NotInitialization.java

 

Java代碼  

1. package com.chenzhou.classloading;  
2. /** 
3.  * ClassName:NotInitialization <br/> 
4.  * Function: 經過數組定義來引用類，不會觸發此類的初始化. <br/> 
5.  * Date:     2012-7-18 上午09:41:14 <br/> 
6.  * @author   chenzhou 
7.  * @version   
8.  * @since    JDK 1.6 
9.  * @see       
10.  */  
11. public class NotInitialization {  
12.     public static void main(String[] args) {  
13.         SuperClass[] scs = new SuperClass[10];  
14.     }  
15. }  

輸出結果爲空

   沒有輸出「SuperClass init！」說明沒有觸發類com.chenzhou.classloading.SuperClass的初始化階段，可是這段代碼會觸發「[Lcom.chenzhou.classloading.SuperClass」類的初始化階段。這個類是由虛擬機自動生成的，該建立動做由newarray觸發。

 

示例三

常量類ConstClass.java

 

Java代碼  

1. package com.chenzhou.classloading;  
2. /** 
3.  * ClassName:ConstClass <br/> 
4.  * Function: 常量在編譯階段會存入調用類的常量池中，本質上沒有直接引用到定義常量的類，所以不會觸發定義常量的類的初始化. <br/> 
5.  * Reason:   TODO ADD REASON. <br/> 
6.  * Date:     2012-7-18 上午09:46:56 <br/> 
7.  * @author   chenzhou 
8.  * @version   
9.  * @since    JDK 1.6 
10.  * @see       
11.  */  
12. public class ConstClass {  
13.     static{  
14.         System.out.println("ConstClass init!");  
15.     }  
16.       
17.     public static final String HELLOWORLD = "hello world";  
18. }  

主類NotInitialization.java

Java代碼  

1. package com.chenzhou.classloading;  
2. /** 
3.  * ClassName:NotInitialization <br/> 
4.  * Function: 非主動實用類字段演示. <br/> 
5.  * Date:     2012-7-18 上午09:41:14 <br/> 
6.  * @author   chenzhou 
7.  * @version   
8.  * @since    JDK 1.6 
9.  * @see       
10.  */  
11. public class NotInitialization {  
12.     public static void main(String[] args) {  
13.         System.out.println(ConstClass.HELLOWORLD);  
14.     }  
15. }  

輸出：hello world

    上面的示例代碼運行後也沒有輸出「SuperClass init！」，這是由於雖然在Java源碼中引用了ConstClass類中的常量HELLOWORLD，可是在編譯階段將此常量的值「hello world」存儲到了NotInitialization類的常量池中，對於常量ConstClass.HELLOWORLD的引用實際上都被轉化爲NotInitialization類對自身常量池的引用了。實際上NotInitialization的Class文件之中已經不存在ConstClass類的符號引用入口了。

   接口的加載過程與類加載的區別在於上面提到的四種場景中的第三種，當類在初始化時要求其父類都已經初始化過了，可是一個接口在初始化時，並不要求其父類都完成了初始化，只有在真正用到父類接口的時候（如引用父接口的常量）纔會初始化。