上一篇部落格Java——深入理解Class物件（一）帶大家簡單認識了一下Java中Class物件。

現在帶大家瞭解一下Class物件的載入及其獲取方式。

1.Class物件的載入

在Java——深入理解Class物件（一）我們已提到過，Class物件是由JVM載入的，那它必然不會是胡亂載入的，肯定有載入時機。

實際上，所有的類都是在對其第一次使用時動態載入到JVM中的。當程式建立第一個對類的靜態成員引用時，就會載入這個被使用的類(實際上載入的就是這個類的位元組碼檔案)。這裡需要注意，使用new操作符建立類的新例項物件也會被當作對類的靜態成員的引用(建構函式也是類的靜態方法)。

由此我們就可以知道，Java程式在它們開始執行之前並非被完全載入到記憶體的，其各個部分是按需載入。

因此，在使用該類時，類載入器首先會檢查這個類的Class物件是否已被載入(類的例項物件建立時依據Class物件中型別資訊完成的)，如果還沒有載入，預設的類載入器就會先根據類名查詢.class檔案(編譯後Class物件被儲存在同名的.class檔案中)，在這個類的位元組碼檔案被載入時，它們必須接受相關驗證，以確保其沒有被破壞並且不包含不良Java程式碼(這是java的安全機制檢測)，完全沒有問題後就會被動態載入到記憶體中，此時相當於Class物件也就被載入記憶體了(畢竟.class位元組碼檔案儲存的就是Class物件)，同時也就可以被用來建立這個類的所有例項物件。

下面通過一個簡單例子來說明Class物件被載入的時機問題（例子引用自Thinking in Java）：

package javatest;

public class SweetShop {
	  public static void print(Object obj) {
	    System.out.println(obj);
	  }
	  public static void main(String[] args) {  
	    print("inside main");
	    new Candy();
	    print("After creating Candy");
	    try {
	      Class.forName("javatest.Gum");
	    } catch(ClassNotFoundException e) {
	      print("Couldn't find Gum");
	    }
	    print("After Class.forName(\"javatest.Gum\")");
	    new Cookie();
	    print("After creating Cookie");
	  }
}


class Candy {
  static {   System.out.println("Loading Candy"); }
}
class Gum {
  static {   System.out.println("Loading Gum"); }
}
class Cookie {
  static {   System.out.println("Loading Cookie"); }
}

 

在上述程式碼中,每個類Candy、Gum、Cookie都存在一個static語句，這個語句會在類第一次被載入時執行，這個語句的作用就是告訴我們該類在什麼時候被載入。

我們來看一下執行結果：

從結果來看，new一個Candy物件和Cookie物件，建構函式將被呼叫，屬於靜態方法的引用，Candy類的Class物件和Cookie的Class物件肯定會被載入，畢竟Candy例項物件的建立依據其Class物件。

比較有意思的是Class.forName（“javatest.Gum”）語句也使得Gum的Class物件被載入。​​​​​​如下圖​

forName方法是Class類的一個static成員方法，所有的Class物件都源於這個Class類，因此Class類中定義的方法將適應所有Class物件。這裡通過forName方法，我們可以獲取到Gum類對應的Class物件引用。因此，如果Gum類之前沒有被載入過的話，呼叫forName方法將會導致Gum類被載入。下面就來認識一下forName方法
 

2.Class.forName方法

通過上面的案例，我們可以知道Class.forName()方法的呼叫將會返回一個對應類的Class物件，因此如果我們想獲取一個類的執行時型別資訊並加以使用時，可以呼叫Class.forName()方法獲取Class物件的引用，這樣做的好處是無需通過持有該類的例項物件引用而去獲取Class物件。

什麼叫通過該類的例項物件引用而去獲取Class物件呢？

下面舉一個例子對比這兩種方法

將上文程式中的main函式修改為：

	  public static void main(String[] args) {

		    try{
		      //通過Class.forName獲取Gum類的Class物件
		      Class clazz=Class.forName("javatest.Gum");
		      System.out.println("forName=clazz:"+clazz.getName());
		    }catch (ClassNotFoundException e){
		      e.printStackTrace();
		    }

		    //通過例項物件獲取Gum的Class物件
		    Gum gum = new Gum();
		    Class clazz2=gum.getClass();
		    System.out.println("new=clazz2:"+clazz2.getName());

		  }

上邊第二種方法就是通過一個例項物件獲取一個類的Class物件，其中的getClass()是從頂級類Object繼承而來的，它將返回表示該物件的實際型別的Class物件引用。）

這時候執行結果如下：

注意：呼叫forName方法時需要捕獲一個名稱為ClassNotFoundException的異常，因為forName方法在編譯器是無法檢測到其傳遞的字串對應的類是否存在的，只能在程式執行時進行檢查，如果不存在就會丟擲ClassNotFoundException異常。

比如我將

  Class clazz=Class.forName("javatest.Gum");

改為

  Class clazz=Class.forName("javatest.Aum");

那麼程式執行的時候就會報錯，如下圖

3.Class字面常量

在Java中存在另一種方式來生成Class物件的引用，它就是Class字面常量，如下：

//字面常量的方式獲取Class物件

Class clazz = Gum.class;

這種方式相對前面兩種方法更加簡單，更安全。

因為它在編譯器就會受到編譯器的檢查，同時由於無需呼叫forName方法效率也會更高，因為通過字面量的方法獲取Class物件的引用不會自動初始化該類。

更加有趣的是，字面常量的獲取Class物件引用方式不僅可以應用於普通的類，也可以應用用介面，陣列以及基本資料型別，這點在反射技術應用傳遞引數時很有幫助。由於基本資料型別還有對應的基本包裝型別，其包裝型別有一個標準欄位TYPE，而這個TYPE就是一個引用，指向基本資料型別的Class物件，其等價轉換如下。（一般情況下更傾向使用.class的形式，這樣可以保持與普通類的形式統一。）

boolean.class = Boolean.TYPE;
char.class = Character.TYPE;
byte.class = Byte.TYPE;
short.class = Short.TYPE;
int.class = Integer.TYPE;
long.class = Long.TYPE;
float.class = Float.TYPE;
double.class = Double.TYPE;
void.class = Void.TYPE;

前面提到過，使用字面常量的方式獲取Class物件的引用不會觸發類的初始化，這裡我們可能需要簡單瞭解一下類載入的過程，如下：

解釋如下：

• 載入：類載入過程的一個階段：通過一個類的完全限定查詢此類位元組碼檔案，並利用位元組碼檔案建立一個Class物件
• 連結：驗證位元組碼的安全性和完整性，準備階段正式為靜態域分配儲存空間，注意此時只是分配靜態成員變數的儲存空間，不包含例項成員變數，如果必要的話，解析這個類建立的對其他類的所有引用。
• 初始化：類載入最後階段，若該類具有超類，則對其進行初始化，執行靜態初始化器和靜態初始化成員變數。
   

由此可知，我們獲取字面常量的Class引用時，觸發的應該是載入階段，因為在這個階段Class物件已建立完成，獲取其引用並不困難，而無需觸發類的最後階段初始化。下面通過小例子來驗證這個過程：

程式碼如下：

package javatest;
import java.util.*;

class Initable {
  //編譯期靜態常量
  static final int staticFinal = 47;
  //非編期靜態常量
  static final int staticFinal2 =
    ClassInitialization.rand.nextInt(1000);
  static {
    System.out.println("Initializing Initable");
  }
}

class Initable2 {
  //靜態成員變數
  static int staticNonFinal = 147;
  static {
    System.out.println("Initializing Initable2");
  }
}

class Initable3 {
  //靜態成員變數
  static int staticNonFinal = 74;
  static {
    System.out.println("Initializing Initable3");
  }
}

public class ClassInitialization {
  public static Random rand = new Random(47);
  public static void main(String[] args) throws Exception {
    //字面常量獲取方式獲取Class物件
    Class initable = Initable.class;
    System.out.println("After creating Initable ref");
    //不觸發類初始化
    System.out.println(Initable.staticFinal);
    //會觸發類初始化
    System.out.println(Initable.staticFinal2);
    //會觸發類初始化
    System.out.println(Initable2.staticNonFinal);
    //forName方法獲取Class物件
    Class initable3 = Class.forName("javatest.Initable3");
    System.out.println("After creating Initable3 ref");
    System.out.println(Initable3.staticNonFinal);
  }
}

執行結果如下：

從輸出結果來看，可以發現，通過字面常量獲取方式獲取Initable類的Class物件並沒有觸發Initable類的初始化，這點也驗證了前面的分析。

同時我們也可以發現，呼叫Initable.staticFinal變數時也沒有觸發初始化，這是因為staticFinal屬於編譯期靜態常量，在編譯階段通過常量傳播優化的方式將Initable類的常量staticFinal儲存到了一個稱為NotInitialization類的常量池中，在以後對Initable類常量staticFinal的引用實際都轉化為對NotInitialization類對自身常量池的引用，所以在編譯期後，對編譯期常量的引用都將在NotInitialization類的常量池獲取，這也就是引用編譯期靜態常量不會觸發Initable類初始化的重要原因。

但在之後呼叫了Initable.staticFinal2變數後就觸發了Initable類的初始化。因為雖然staticFinal2被static和final修飾，但其值在編譯期並不能確定，因此staticFinal2並不是編譯期常量，使用該變數必須先初始化Initable類。Initable2和Initable3類中都是靜態成員變數並非編譯期常量，引用都會觸發初始化。至於forName方法獲取Class物件，肯定會觸發初始化，這點在前面已分析過。

到這裡，幾種獲取Class物件的方式也都分析完，我們可以得出小結論：

• 獲取Class物件引用的方式又3種，即通過繼承自Object類的getClass方法，Class類的靜態方法forName以及字面常量的方式”.class”。
• 例項類的getClass方法和Class類的靜態方法forName都將會觸發類的初始化階段，而字面常量獲取Class物件的方式則不會觸發初始化。
• 初始化是類載入的最後一個階段，也就是說完成這個階段後類也就載入到記憶體中(Class物件在載入階段已被建立)，此時可以對類進行各種必要的操作了（如new物件，呼叫靜態成員等），在這個階段，才真正開始執行類中定義的Java程式程式碼或者位元組碼。
   

關於類載入的初始化場景，大家可以參照Java——類什麼時候會進行初始化。

Biu~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~pia！

參考文章：https://blog.csdn.net/javazejian/article/details/70768369