Java初始化順序

Java 變量類型

1. 實例變量；
2. 類變量；

Java初始化途徑

實例變量

• 聲明時，初始化；
• 非靜態初始化塊內，初始化；
• 構造函數內，初始化；

實例1:

public class bean1 {
	int d;
	int e;
	int c;
	int b;
	int f;
	{
		c = 3;
	}
	int a = 1;
	{
		b = 2;
	}
	public bean1() {
		d = 4;
		f = 5;
		e = 6;
	}
	public int geta() {
			return a;
	}
}

使用javap -c bean1.class查看反彙編代碼以下：

Compiled from "bean1.java"
public class initialization.bean1 {
  int d;
  int e;
  int c;
  int b;
  int f;
  int a;
  public initialization.bean1();
    Code:
       0: aload_0
       1: invokespecial #1                  // Method java/lang/Object."<init>":()V
       4: aload_0
       5: iconst_3　　//初始化c
       6: putfield      #2                  // Field c:I
       9: aload_0
      10: iconst_1　　//初始化a　　
      11: putfield      #3                  // Field a:I
      14: aload_0
      15: iconst_2　　//初始化b
      16: putfield      #4                  // Field b:I
      19: aload_0
      20: iconst_4　　//初始化d
      21: putfield      #5                  // Field d:I
      24: aload_0
      25: iconst_5
      26: putfield      #6                  // Field f:I
      29: aload_0
      30: bipush        6
      32: putfield      #7                  // Field e:I
      35: return

  public int geta();
    Code:
       0: aload_0
       1: getfield      #3                  // Field a:I
       4: ireturn
}

結論:實例變量的初始化均在public initialization.bean1()當中完成，不管是在聲明時直接初始化，仍是在代碼塊當中初始化，本質均在構造函數裏面進行初始化，在構造函數當中的初始化順序取決於在定義直接初始化和代碼塊初始化中的順序。

類變量

• 聲明時，初始化；
• 靜態初始化塊內，初始化；

實例2:

package initialization;
public class bean2 {
	static int d;
	static int e = 5;
	static int c;
	int b;
	int f;
	int a = 1;
	static {
		c = 3;
		System.out.println("hello,static");
	}
	{
		b = 2;
		System.out.println("hello");
	}
	static {
		d = 4;
	}
	
	public bean2() {
		f = 6;
	}
	
	public int geta() {
			return a;
	}
}

bean2輸出結果爲：

hello,static
hello

javap -c bean2.class查看反彙編代碼以下:

Compiled from "bean2.java"
public class initialization.bean2 {
  static int d;

  static int e;

  static int c;

  int b;

  int f;

  int a;

  public initialization.bean2();
    Code:
       0: aload_0
       1: invokespecial #1                  // Method java/lang/Object."<init>":()V
       4: aload_0
       5: iconst_1	//初始化a
       6: putfield      #2                  // Field a:I
       9: aload_0
      10: iconst_2	//初始化b
      11: putfield      #3                  // Field b:I
      14: aload_0
      15: bipush        6
      17: putfield      #4                  // Field f:I
      20: return

  public int geta();
    Code:
       0: aload_0
       1: getfield      #2                  // Field a:I
       4: ireturn

  static {};
    Code:
       0: iconst_5	//初始化e
       1: putstatic     #5                  // Field e:I
       4: iconst_3	//初始化c
       5: putstatic     #6                  // Field c:I
       8: iconst_4	//初始化d
       9: putstatic     #7                  // Field d:I
      12: return
}

結論:實例變量的初始化均在public initialization.bean2()當中完成，不管是在聲明時直接初始化，仍是在代碼塊當中初始化，本質均在構造函數裏面進行初始化，在構造函數當中的初始化順序取決於在 定義直接初始化和代碼塊初始化中的順序；類變量在static {}中完成，且初始順序以代碼中順序爲主，類變量在實例變量前執行；

關於java final能夠查看：java final ;