[轉]JAVA程序執行順序，你了解了嗎：JAVA中執行順序，JAVA中賦值順序

 

本文主要介紹以下兩塊內容的執行順序，熟悉的大蝦可以直接飄過。

     一。JAVA中執行順序

 

1. 靜態塊
2. 塊
3. 構造器
4. 父類構造器

 

    二。JAVA中賦值順序

 

1.       靜態塊直接賦值
2.       塊直接賦值
3.       父類繼承的屬性已賦值
4.       靜態變量聲明時賦值
5.       成員變量聲明時賦值
6.       構造器賦值

 

 

 

 第一部分很好測試，我們只需要寫一個子類，類中定義一個靜態塊，一個普通塊，一個構造器，它的父類構造器，都打印一條語句，即可明白它們直接的執行順序

 

 

 

Mastiff類

 

 

<span style="font-size: medium;">/**
 * 子類藏獒
 */
public class Mastiff extends Dog {
    public Mastiff() {
        System.out.println("Mastiff");
    }

    {
        System.out.println("block");
    }
    static {
        System.out.println("static block");
    }

    public static void  main(String[] args){
        Mastiff mastiff=new Mastiff();

    }
}
</span>

 

 

 

 

  DOG類

 

 

<span style="font-size: medium;">/**
 *DOG父類
 */
public class Dog {
    public Dog() {
        System.out.println("Dog");
    }
}
</span>

 

 

運行結果為：

 

 

static block
Dog
block
Mastiff

 

 

 

也就是說，在我們的程序中，實例化一個類對象的時候，運行順序為：

 

1.   靜態塊
2.   父類構造器
3.   本類中的塊
4.   本類的構造器 

我們可以更進一步，如果在父類中也有塊和靜態塊呢？

    DOG類改進后源碼 

<span style="font-size: medium;">/**
 *DOG父類
 */
public class Dog {
    public Dog() {
        System.out.println("Dog");
    }
    static{
        System.out.println("super static block");
    }

    {
        System.out.println("super block");
    }
}
</span>

  

   Mastiff改進后源碼

<span style="font-size: medium;">/**
 * 子類藏獒
 */
public class Mastiff extends Dog {
    public Mastiff() {
        System.out.println("Mastiff");
    }

    {
        System.out.println("block");

    }
    static {
        System.out.println("static block");
    }

    public static void  main(String[] args){
        Mastiff mastiff=new Mastiff();
    }
}
</span>

 

運行的結果為：

 

super static block
static block
super block
Dog
block
Mastiff

 也就是說此時的運行順序為：

1.    父類靜態塊
2.    自身靜態塊
3.    父類塊
4.    父類構造器
5.    自身塊
6.    自身構造器 

 

 

  好了，知道了運行的順序，那么這是為什么呢？

 

         這就要從JVM中類的裝載機制和實例化機制開始說起，這里因為主題原因，先不討論，有興趣的同學可以自己查資料。

 

 

我們再來討論第二個問題，一個變量的值，它有可能在哪些地方確定呢？？

 

1. 從父類繼承該值（包括：1.作為父類的成員變量已經賦值  2.在父類的塊中賦值  3.在父類的構造器中賦值）
2. 在構造器中對其進行賦值
3. 在塊中進行賦值
4. 在方法調用中進行賦值

 

  現在假設在我們剛剛的例子中，有一個變量type，表示狗的品種

 

 

<span style="font-size: medium;">/**
 *DOG父類
 */
public class Dog {
    public String type="父類成員變量賦的值";
    public Dog() {
        System.out.println("父類構造器--type-->"+type);
        type="父類構造器賦的值";
                   System.out.println("父類構造器----type--->"+type);
    }

    {
        System.out.println("block---type--->"+type);
        type="父類塊賦的值";
    }
}
</span>

 

   

<span style="font-size: medium;">/**
 * 子類藏獒
 */
public class Mastiff extends Dog {
    public String type="成員變量賦的值";
    public Mastiff() {
        System.out.println("構造器---type--->"+type);
        type="構造器賦的值";
    }

    public void say(){
        System.out.println("say---type---->"+type);
    }

    {
        System.out.println("block---type--->"+type);
        type="塊賦的值";

    }

    public static void  main(String[] args){
        Mastiff mastiff=new Mastiff();
        mastiff.say()</span><span style="font-size: medium;">;</span><span style="font-size: medium;">
    }
}
</span>

   

 

 

 執行結果如下：

block---type--->父類成員變量賦的值
父類構造器--type-->父類塊賦的值
父類構造器----type--->父類構造器賦的值
block---type--->成員變量賦的值
構造器---type--->塊賦的值
say---type---->構造器賦的值

 

 

 

答案很明顯，賦值順序為：

1. 父類成員變量賦值
2. 父類塊賦值
3. 父類構造器賦值
4. 自身成員變量賦值
5. 自身塊賦值
6. 自身構造器賦值

 

 

 

 結合我們前面說的程序中的執行順序，這個顯然是很好理解的：

   1.成員變量賦值>>>塊賦值>>>構造器賦值

   2.父類的塊>>父類構造器>>自身塊>>自身構造器

 

 又因為一個成員變量是不可能在靜態變量中賦值的，而且又前面程序執行順序可知

    靜態塊>>塊

 

 

所以，程序的賦值步驟為

1. 父類的靜態變量賦值
2. 自身的靜態變量賦值
3. 父類成員變量賦值
4. 父類塊賦值
5. 父類構造器賦值
6. 自身成員變量賦值
7. 自身塊賦值
8. 自身構造器賦值