static{}語句塊詳解

　　static{}(即static塊)，會在類被加載的時候執行且僅會被執行一次，通常用來初始化靜態變量和調用靜態方法。

　　舉ge例子：

public class Test
{
    public static int X = 100;

    public final static int Y = 200;

    public Test()
    {
        System.out.println("Test構造函數執行");
    }

    static
    {
        System.out.println("static語句塊執行");
    }

    public static void display()
    {
        System.out.println("靜態方法被執行");
    }

    public void display_1()
    {
        System.out.println("實例方法被執行");
    }

}

　　

public class StaticBlockTest
{
    public static void main(String args[])
    {
        try
        {
            Class.forName("Test");
            Class.forName("Test");
        }
        catch (ClassNotFoundException e)
        {
            e.printStackTrace();
        }
    }
}

　　結果:你會發現雖然執行了兩條Class.forName("Test")語句，可是，只輸出了一條"靜態方法被執行"語句；其實第二條Class.forName()語句已經無效了，由於在虛擬機的生命週期中一個類只被加載一次；又由於static{}是伴隨類加載執行的，因此，無論你new多少次對象實例，static{}都只執行一次。

　　--關於類加載請看本文的附錄。

 

 一、static{}語句塊執行的時機，即類被加載準確含義:

　　（1）用Class.forName()顯示加載的時候;

　　（2）實例化一個類的時候，如將main()函數的內容改成:Test t=new Test();//這種形式其實和1相比，原理是相同的，都是顯示的加載這個類，讀者能夠驗證Test t=new Test();和Test t=(Test)Class.forName().newInstance();這兩條語句效果相同。

　　（3）調用類的靜態方法的時候，如將main()函數的內容改成:Test.display();

　　（4）調用類的靜態變量的時候，如將main()函數的內容改成:System.out.println(Test.X);

 

　　整體來講就這四種狀況，可是咱們特別須要注意一下兩點:

　　（1）調用類的靜態常量的時候，是不會加載類的，即不會執行static{}語句塊，讀者能夠本身驗證一下(將main()函數的內容改成System.out.println(Test.Y);)，你會發現程序只輸出了一個200；(這是java虛擬機的規定，當訪問類的靜態常量時，若是編譯器能夠計算出常量的值，則不會加載類，不然會加載類)

　　（2）用Class.forName()形式的時候，咱們也能夠本身設定要不要加載類，如將Class.forName("Test")改成 Class.forName("Test",false,StaticBlockTest.class.getClassLoader())，你會發現程序什麼都沒有輸出，即Test沒有被加載，static{}沒有被執行。

 

 

二、static{}語句塊的執行次序

　　（1）當一個類中有多個static{}的時候，按照static{}的定義順序，從前日後執行；

　　（2）先執行完static{}語句塊的內容，纔會執行調用語句；

public class TestStatic
{
    static
    {
        System.out.println(1);
    }
    static
    {
        System.out.println(2);
    }
    static
    {
        System.out.println(3);
    }

    public static void main(String args[])
    {
        System.out.println(5);
    }

    static
    {
        System.out.println(4);
    }
}

結果:程序會輸出1，2，3，4，5

 

　　（3）若是靜態變量在定義的時候就賦給了初值(如 static int X=100)，那麼賦值操做也是在類加載的時候完成的，而且當一個類中既有static{}又有static變量的時候，一樣遵循「先定義先執行」的原則；

class Test
{
    public static int X = 300;
    static
    {
        System.out.println(X);
        X = 200;
        System.out.println(X);
    }
}

public class StaticBlockTest
{
    public static void main(String args[])
    {
        System.out.println(Test.X);
    }
}

結果:程序會依次輸出300，200，200，先執行完X=300，再執行static{}語句塊。

 

（4）訪問靜態常量，若是編譯器能夠計算出常量的值，則不會加載類。即若是A類的靜態常量值是經過B類的靜態常量賦值，則不加載，不然須要加載A類。

public class TestA
{
    public static final int a = TestB.a;

    public static final int b = TestB.b;

　　 public static final int c = 90;

　　static
    {
        System.out.println("TestA static語句塊執行");
    }
}

public class TestB
{
    public static int a = 90;

    public static final int b = 90;

    static
    {
        System.out.println("TestB static語句塊執行");
    }
}

public class StaticTest
{
    public static void main(String args[])
    {
        System.out.println(TestA.a);
    }
}

System.out.println(TestA.a);的結果：

TestB static語句塊執行
TestA static語句塊執行
90

System.out.println(TestA.b)和System.out.println(TestA.c)的結果：

90

　　

附錄:

類加載:Java命令的做用是啓動虛擬機，虛擬機經過輸入流，從磁盤上將字節碼文件(.class文件)中的內容讀入虛擬機，並保存起來的過程就是類加載。

類加載特性 :
      *在虛擬機的生命週期中一個類只被加載一次。
      *類加載的原則：延遲加載，能少加載就少加載，由於虛擬機的空間是有限的。
      *類加載的時機：
      1）第一次建立對象要加載類.
      2）調用靜態方法時要加載類,訪問靜態屬性時會加載類。
      3）加載子類時一定會先加載父類。
      4）建立對象引用不加載類.
      5) 子類調用父類的靜態方法時
          (1)當子類沒有覆蓋父類的靜態方法時，只加載父類，不加載子類
          (2)當子類有覆蓋父類的靜態方法時，既加載父類，又加載子類
      6）訪問靜態常量，若是編譯器能夠計算出常量的值，則不會加載類,例如:public static final int a =123;不然會加載類,例如:public static final int a = math.PI。

 

轉自：http://blog.csdn.net/lubiaopan/article/details/4802430