Java——对象初始化顺序使用详解

一、 代码块的概念

在探究对象初始化顺序之前，我们先通过代码来了解一下代码块的概念。

class test{
  public static string str1; //静态字段

  public string str2;     //普通字段

  static{           
    //静态代码块
  }

  {
    //构造代码块
  }

  public test() { 
    //构造函数
  }
}

二、 创建子类对象时，对象的初始化顺序

1. 字段初始化、代码块和构造函数的执行顺序

我们先看代码和结果

public class codeblocktest {
  public static void main(string[] args) {
    child child = new child();
  }
}
class father {
  public static string fatherstr1 = "fatherstr1（静态字段初始化值）";

  public string fatherstr2 = "fatherstr2（字段初始化值）";
  static {
    system.out.println("父类静态代码块：" + fatherstr1);
    fatherstr1 = "fatherstr1（静态代码块赋值）";
  }
  {
    system.out.println("父类构造代码块：" + fatherstr2);
    fatherstr2 = "fatherstr2（构造代码块赋值）";
  }
  public father() {
    system.out.println("父类构造函数块：" + fatherstr2);
    fatherstr2 = "fatherstr2（构造函数赋值）";
  }
}
class child extends father {
  public static string childstr1 = "childstr1（静态字段初始化值）";
  public string childstr2 = "childstr2（字段初始化值）";
  static {
    system.out.println("子类静态代码块：" + childstr1);
    childstr1 = "childstr1（静态代码块赋值）";
  }
  {
    system.out.println("子类构造代码块：" + childstr2);
    childstr2 = "childstr2（构造代码块赋值）";
  }
  public child() {
    system.out.println("子类构造函数：" + childstr2);
    childstr2 = "childstr2（构造函数赋值）";
  }
}
//  输出结果：
//  父类静态代码块：fatherstr1（静态字段初始化值）
//  子类静态代码块：childstr1（静态字段初始化值）
//  父类构造代码块：fatherstr2（字段初始化值）
//  父类构造函数块：fatherstr2（构造代码块赋值）
//  子类构造代码块：childstr2（字段初始化值）
//  子类构造函数：childstr2（构造代码块赋值）

通过每执行一个代码块或构造函数，输出字段在上一代码块执行后的值，以此来探究对象的初始化顺序。

由目前的输出结果可知，对于对象的初始化顺序，我们可以得出以下结论：

1. 父类静态字段初始化

2. 父类静态代码块、子类静态字段初始化 （接下来探究两者的顺序）

3. 子类静态代码块

4. 父类普通字段初始化

5. 父类构造代码块

6. 父类构造函数

7. 子类普通字段初始化

8. 子类构造代码块

9. 子类构造函数

2. 父类静态代码块和子类静态字段初始化的执行顺序

还是一样，我们通过代码的执行结果来探究两者间的执行顺序。

public class codebloactest2 {
  public static void main(string[] args) {
    child child = new child();
  }
}
class father {
  public static string fatherstr = "（静态字段初始化值）";
  static {
    system.out.println("父类静态代码块：fatherstr" + fatherstr);
    fatherstr = "（静态代码块赋值）";
  }
}
class child extends father {
  public static string childstr = fatherstr;
  static {
    system.out.println("子类静态代码块：childstr = fatherstr" + childstr);
    childstr = "（静态代码块赋值）";
  }
}
//  输出结果：
//  父类静态代码块：fatherstr（静态字段初始化值）
//  子类静态代码块：childstr = fatherstr（静态代码块赋值）

我们在子类静态字段childstr初始化的时候，赋的是父类静态字段fatherstr的值。由输出结果可知，childstr初始化后的值是父类静态代码块执行后赋予fatherstr的值。由此可知两者的执行顺序为：父类静态代码块==>子类静态字段初始化

三、 结论

父类静态字段初始化

父类静态代码块

子类静态字段初始化

子类静态代码块

父类普通字段初始化

父类构造代码块

父类构造函数

子类普通字段初始化

子类构造代码块

子类构造函数

通过结论我们可以很明显的看出：static字段、代码块的执行顺序优先于非static字段、代码块。这是因为在静态域是属于类的，在类加载后就一直存在；而普通域需要创建对象才能访问。而在创建对象时，需要先加载父类，然后再加载子类，因此父类的静态字段初始化和静态代码块执行先于子类。

以上内容希望对各位朋友有所帮助