記得在學校初學java時講過，當時也懂了，不過今天看到一個問題時竟然又看不懂，理解不了了....果斷重新梳理了一遍。先上題：

class T  implements Cloneable{
    public static int k = 0;
    public static T t1 = new T("t1");
    public static T t2 = new T("t2");
    public static int i = print("i");
    public static int n = 99;
    public static String s = "s";

    public int j = print("j");
    {
        print("構造快");
    }

    static {
        print("靜態塊");
    }

    public T(String str) {
        System.out.println((++k) + ":" + str + "    i=" + i + "  n=" + n + "   s="+ s);
        ++n; ++ i;
    }

    public static int print(String str){
        System.out.println((++k) +":" + str + "   i=" + i + "   n=" + n + "   s="+ s);
        ++n;
        return ++ i;
    }

    public static void main(String[] args){
        System.out.println("main");
        T t = new T("init");
    }
}
 

1:j   i=0   n=0   s=null
2:構造快   i=1   n=1   s=null
3:t1    i=2  n=2   s=null
4:j   i=3   n=3   s=null
5:構造快   i=4   n=4   s=null
6:t2    i=5  n=5   s=null
7:i   i=6   n=6   s=null
8:靜態塊   i=7   n=99   s=s
main
9:j   i=8   n=100   s=s
10:構造快   i=9   n=101   s=s
11:init    i=10  n=102   s=s

先初始化靜態變數跟靜態塊，然後是例項化過程中先初始化成員變數跟構造塊，然後是建構函式呼叫。（靜態塊，靜態屬性或者成員變數都是按照申明順序）

首先，類裝載，初始化靜態類跟靜態塊

所以執行第二行初始化k，

接下來第三行，初始化T物件，

初始化T物件就到了第9行，此時int 型別 i,n 都未賦值，預設為0，String型別s 則為null，所以打印出 1:j   i=0   n=0   s=null

然後接下來就是10-12行的構造塊，因為上一行i,n 都自增了，所以打印出 2:構造快   i=1   n=1   s=null

成員變數跟構造塊初始化完畢，呼叫建構函式，於是執行18-21，打印出 3:t1    i=2  n=2   s=null 

OK，t1物件初始化完畢了，t2物件同理，不再贅述。

然後就到了第5行，執行變數i的賦值，打印出 7:i   i=6   n=6   s=null

然後執行第6行，變數n賦值為99,注意，n在這之前是6，現在變為99了，接下來的列印能發現區別。

第7行，s賦值為“s”，變數s不再為null了

然後就到靜態塊了，列印結果為 8:靜態塊   i=7   n=99   s=s 看n 跟s的變化；

OK，執行到這完成了一個階段的初始化了，可以理解為是類的裝載，然後就到程式的入口函式main方法中來了 29-32

main函式中先列印了main 然後例項化了個T物件，T物件的例項化同t1 t2的例項化過程，

列印結果自然為main
9:j   i=8   n=100   s=s
10:構造快   i=9   n=101   s=s
11:init    i=10  n=102   s=s

=================================華麗的分割線=====================================

再來個蛋疼的例子學習下：

1. package test01;     
2. class Singleton {     
3. public static Singleton singleton = new Singleton();     
4. public static int a;     
5. public static int b = 0;     
6. private Singleton() {     
7. super();     
8.         a++;     
9.         b++;     
10.     }     
11. public static Singleton GetInstence() {     
12. return singleton;     
13.     }     
14. }     
15. public class MyTest {     
16. /**   
17.      * @param args   
18.      */
19. public static void main(String[] args) {     
20.         Singleton mysingleton = Singleton.GetInstence();     
21.         System.out.println(mysingleton.a);     
22.         System.out.println(mysingleton.b);     
23.     }     
24. }

分析下流程：首先對Singleton的所有的靜態變數分配空間，賦預設的值，所以在這個時候，singleton=null、a=0、b=0。注意b的0是預設值，並不是我們賦的0。

然後對靜態變數賦值。singleton = new Singleton();呼叫構造方法。構造方法裡面a=1、b=1。之後接著順序往下執行，a沒有賦值，保持原狀a=1。b被賦值了，b原先的1被覆蓋，b=0。所以結果就是這麼來的。

================================繼承情況下=========================================

class Test{
    static{
        System.out.println("父類static 塊 1  執行");
    }
    static Sample staticSam1=new Sample("父類 靜態成員staticSam1初始化");
    Sample sam1=new Sample("父類 sam1成員初始化");
    static Sample staticSam2=new Sample("父類 靜態成員staticSam2初始化");
    static{
        System.out.println("父類 static 塊 2  執行");
    }
    Test()
    {
        System.out.println("父類 Test預設建構函式被呼叫");
    }
    Sample sam2=new Sample("父類 sam2成員初始化");

}

class Sample
{
    Sample(String s)
    {
        System.out.println(s);
    }
    Sample()
    {
        System.out.println("Sample預設建構函式被呼叫");
    }
}

class TestSub extends Test
{
    static Sample staticSamSub=new Sample("子類 靜態成員staticSamSub初始化");
    TestSub()
    {
        System.out.println("子類 TestSub 預設建構函式被呼叫");
    }
    Sample sam1=new Sample("子類 sam1成員初始化");
    static Sample staticSamSub1=new Sample("子類 靜態成員staticSamSub1初始化");

    static{System.out.println("子類 static 塊  執行");}
    Sample sam2=new Sample("子類 sam2成員初始化");
}

父類static 塊 1  執行
父類 靜態成員staticSam1初始化
父類 靜態成員staticSam2初始化
父類 static 塊 2  執行
子類 靜態成員staticSamSub初始化
子類 靜態成員staticSamSub1初始化
子類 static 塊  執行
父類 sam1成員初始化
父類 sam2成員初始化
父類 Test預設建構函式被呼叫
子類 sam1成員初始化
子類 sam2成員初始化
子類 TestSub 預設建構函式被呼叫