類的加載與對象創建過程
Java中每個類的編譯代碼都存在于他自己的獨立的文件中。該文件只在需要使用程序代碼時才會被加載初始化。一般來說“類的代碼在初次使用時才加載”，這通常是指加載發生于創建類的第一個對象之時，但訪問static域或static方法時，也會發生加載。
“初始化”和“創建”是捆綁在一起的，二者不能分離。假設有個名為Dog的類，那么該類的創建過程如：
- 即使沒有顯示地使用static關鍵字，構造器實際上也是靜態方法。因此，當首次創建Dog的對象時，或者Dog的靜態方法/靜態域被首次訪問時，Java解釋器必須查找類路徑，以定位Dog.class文件。
- 然后載入Dog.class,有關靜態初始化的所有動作都會執行。因此，靜態初始化只在Class對象首次加載的時候進行一次。
- 當用new創建Dog對象時,首先在堆上為Dog對象分匹配足夠的存儲空間。
- 這塊存儲空間會被清零，這就自動的將Dog對象中的所有基本類型設置成默認值，而引用類型被設置成了null。
- 執行所有出現于字段定義處的初始化動作。
- 執行構造器
構造器初始化
成員變量在聲明后如果沒有為其賦值，則編譯器會默認為其賦上默認值，而局部變量則不會，在運行時如果局部變量沒有初始化則會拋出異常。編譯器在通過構造器創建對象的過程中發現該類中有成員變量，則先初始化成員變量然后再執行構造器的初始化內容。如：
public class Test {
int i ;
{
System.out.println(i); //構造代碼塊優先于構造方法執行
i++;
}
public Test (){
System.out.println(i);
}
public static void main(String[] args){
new Test();
}
}
輸出：0; 1
我們可以用構造器來進行初始化，在運行時刻，可以調用方法或執行某些動作來確定初始值；但是，我們無法阻止自動初始化的進行，他將在構造器被調用之前發生。正如上面示例所見，成員變量先被初始化為0，然后變為1。
非靜態數據初始化
在類的內部，變量定義的先后順序決定了初始化的順序。即使成員變量定義散布于方法之間，他們仍舊會在任何方法包括構造器執行之前得到初始化。例如：
class Window{
public Window(int marker){
System.out.println("Window ("+marker+")");
}
}
class House{
Window w1 = new Window(1);
public House(){
System.out.println("House()");
w3 = new Window(33);
}
Window w2 = new Window(2);
public void f(){
System.out.println("f()");
}
Window w3 = new Window(3);
}
public class Initialization {
public static void main(String[] args){
House h = new House();
h.f();
}
}
輸出：
Window (1)
Window (2)
Window (3)
House()
Window (33)
f()
靜態數據的初始化
無論創建多少個對象，靜態數據只占用一份存儲區域。static關鍵字不能應用于局部變量，因此它只能作用于域。如果一個域是基本類型域，而且也沒有對它進行初始化，那么它就會獲得基本類型的初始值；如果是引用對象，那么它的默認初始值就是null。下面的示例說明靜態域是如何初始化的。
class Bowl {
public Bowl(int marker) {
System.out.println("Bowl(" + marker + ")");
}
public void f1(int marker) {
System.out.println("f1(" + marker + ")");
}
}
class Table {
static Bowl bowl = new Bowl(1);
public Table() {
System.out.println("Table()");
bow2.f1(1);
}
public void f2(int marker) {
System.out.println("f2(" + marker + ")");
}
static Bowl bow2 = new Bowl(2);
}
class Cupboard {
Bowl bowl3 = new Bowl(3);
static Bowl bowl4 = new Bowl(4);
public Cupboard() {
System.out.println("Cupboard()");
bowl4.f1(2);
}
public void f3(int marker) {
System.out.println("f3(" + marker + ")");
}
static Bowl bowl5 = new Bowl(5);
}
public class StaticInitialization {
public static void main(String[] args) {
System.out.println("Creating new Cupboard() in main 1");
new Cupboard();
System.out.println("Creating new Cupboard() in main 2");
new Cupboard();
table.f2(1);
cupboard.f3(1);
}
static Table table = new Table();
static Cupboard cupboard = new Cupboard();
}
輸出：
Bowl(1)
Bowl(2)
Table()
f1(1)
Bowl(4)
Bowl(5)
Bowl(3)
Cupboard()
f1(2)
Creating new Cupboard() in main 1
Bowl(3)
Cupboard()
f1(2)
Creating new Cupboard() in main 2
Bowl(3)
Cupboard()
f1(2)
f2(1)
f3(1)
Bowl類是的看到類的創建，而Table類和Cupboard類在它們的類定義中加入了Bowl類型的靜態成員變量。注意，在靜態數據定義之前，Cupboard類先定義了一個Bowl類型的非靜態數據成員bowl3.
由輸出可見，靜態初始化只有在必要時刻才會進行。如果不創建Table對象，也不引用Table.bowl1或Table.bowl2,那么靜態的Bowl bowl1和bowl2永遠都不會被創建，只有在第一個Table對象被創建（或者第一次訪問靜態數據）的時候，它們才會被初始化。此后，靜態數據不會再被初始化。
類的初始化順序：先靜態對象（如果它們未因前面的對象創建過程而被初始化），然后非靜態對象。從輸出結果可以這看出這一點。要執行main()方法，必須加載StaticInitialization類，然后靜態域table和cupboard被初始化，這導致它們對應的類也被加載，并且由于它們包含靜態的Bowl對象，因此Bowl隨后也被加載，這樣在這個特殊的程序中，所有類在main()開始之前就都被夾在了。實際開發中遇到這樣的情況很少。
數組初始化
數組只是相同類型的，用一個標識符名稱封裝到一起的一個對象序列或基本類型數據序列。類似于 int[] arr 和 int arr[]都稱之為數組；由于編譯器不允許指定數組大小，所以我們現在擁有的只是對數組的一個引用（我們已經為該引用分配了足夠的內存空間），而且沒有給數組對象本身分配任何空間。為了給創建相應的存儲空間，必須寫初始化表達式。數組可以用類似于：int[] arr = {1,2,3};這樣特殊的方式初始化。
在Java中可以將一個數組賦值給另一個數組：
int[] a1 = {1,2,3,4,5};
int[] a2;
a2 = a1;
其實這是只是復制了一個引用，就像下面這樣：
public class ArrayTest {
public static void main(String[] args) {
int[] a1 = {1, 2, 3, 4, 5};
int[] a2;
a2 = a1;
for (int i = 0; i < a2.length; i++) {
a2[i] = a2[i] + 1;
}
for (int i = 0; i < a1.length; i++) {
System.out.println("a1[" + i + "]= " + a1[i]);
}
}
}
輸出：
a1[0]= 2
a1[1]= 3
a1[2]= 4
a1[3]= 5
a1[4]= 6
有以上實例可以看出，a1有初始值，a2沒有，把a1賦值給a2后，由于a1和a2都是相同數組的別名，所以a2對數組做的修改在a1中也能看到。所有數組中都有一個固定成員，那就是length，這與String里獲取長度的方法不同，String是length()方法，不是成員。
數組的創建發生在運行時期，所以在編譯時期不能確定數組里需要多少個元素，可以直接用new在數組里創建元素。盡管創建的是基本數據類型數組，new任然可以工作。如：
public class ArrayTest {
public static void main(String[] args) {
int[] a;
Random random = new Random(12324);
a = new int[random.nextInt(20)]; //產生0到20之間的一個隨機數
System.out.println("length of a = "+a.length);
System.out.println(Arrays.toString(a));
}
}
輸出：
length of a = 12
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
如果可能的話盡量在數組定義時就初始化。
繼承與初始化
class Insect {
private int i = 9;
protected int j;
public Insect() {
System.out.println("i = " + i + " ,j = " + j);
j = 39;
}
private static int x1 = printInit("static Insect.x1 initialized");
public static int printInit(String s) {
System.out.println(s);
return 47;
}
}
public class Beetle extends Insect {
private int k = printInit("Beetle.k initialized");
public Beetle() {
System.out.println("k= " + k);
System.out.println("j= " + j);
}
private static int x2 = printInit("static Beetle.x2 initialized");
public static void main(String[] srgs) {
System.out.println("Beetle constructor");
Beetle beetle = new Beetle();
}
}
輸出：
static Insect.x1 initialized
static Beetle.x2 initialized
Beetle constructor
i = 9 ,j = 0
Beetle.k initialized
k= 47
j= 39
從以上實例可以得知：程序運行后的第一件事就是試圖訪問Beetle的main方法，于是加載器開始啟動并找到Beetle類的編譯代碼。在對它進行加載的過程中發現它有一個基類，于是他繼續進行加載。即使在Beetle類中沒有創建該基類對象，這也會發生。如果該基類還有它自身的基類，那么第二個基類就會被加載，如此類推。接下來，根基類中的static初始化，然后是下一個導出類(子類)，如此類推。這種方式很重要，因為導出類的static初始化可能依賴于基類成員是否被正確初始化。
參考自《Java編程思想》
