Java初始化（initialization）其实包含两部分：
1.类的初始化（initialization class & interface）
2.对象的创建（creation of new class instances）。
因为类的初始化其实是类加载（loading of classes）的最后一步，所以很多书中把它归结为“对象的创建”的第一步。其实只是看问题的角度不同而已。为了更清楚的理解，这里还是分开来。
顺序：
应为类的加载肯定是第一步的，所以类的初始化在前。大体的初始化顺序是：
类初始化 -> 子类构造函数 -> 父类构造函数 -> 实例化成员变量 -> 继续执行子类构造函数的语句
下面结合例子，具体解释一下。
1。类的初始化（Initialization classes and interfaces），其实很简单，具体来说有：
（a）初始化类（initialization of class），是指初始化static field 和执行static初始化块。
例如：
class Super {
static String s = “initialization static field”; //初始化static field，其中“= “initialization static field” ”又叫做static field initializer<br style="word-wrap:break-word"> // static初始化块，又叫做static initializer，或 static initialization block<br style="word-wrap:break-word">
static {<br style="word-wrap:break-word">
System.out.println(“This is static initializer”);<br style="word-wrap:break-word">}
}
复制代码
btw，有些书上提到static initializer 和 static field initializer 的概念，与之对应的还有 instance initializer 和 instance variable initializer。例子中的注释已经解释了其含义。
（b）初始化接口（initialization of interface），是指初始化定义在该interface中的field。
注意
--initialization classes 时，该class的superclass 将首先被初始化，但其实现的interface则不会。
--initialization classes 时，该class的superclass，以及superlcass的superclass 会首先被递归地初始化，一直到java.lang.Object为止。但initialiazation interface的时候，却不需如此，只会初始化该interface本身。
--对于由引用类变量（class field）所引发的初始化，只会初始化真正定义该field的class。
--如果一个static field是编译时常量（compile-time constant），则对它的引用不会引起定义它的类的初始化。
为了帮助理解最后两点，请试试看下面的例子：
public class Initialization {
<br style="word-wrap:break-word">
public static void main(String[] args) {<br style="word-wrap:break-word">
<br style="word-wrap:break-word">
System.out.println(Sub.x); // Won't cause initialization of Sub, because x is declared by S, not Sub.<br style="word-wrap:break-word">
// 不会引起Sub类的初始化，因为x是定义在Super类中的<br style="word-wrap:break-word">
System.out.println("-------------------------");<br style="word-wrap:break-word">
System.out.println(Sub.y); // Won't cause initialization of Sub, because y is constant.<br style="word-wrap:break-word">
// 不会引起Sub类的初始化，因为y是常量<br style="word-wrap:break-word">
System.out.println("-------------------------");<br style="word-wrap:break-word">
System.out.println(Sub.z = 2004); // Will cause initialization of Sub class<br style="word-wrap:break-word">// 将会引起Sub的初始化
}<br style="word-wrap:break-word">}
class Super{
static int x = 2006;<br style="word-wrap:break-word">}
class Sub extends Super {
<br style="word-wrap:break-word">
static final int y = 2005;<br style="word-wrap:break-word">
<br style="word-wrap:break-word">static int z;
<br style="word-wrap:break-word">static {
System.out.println("Initialization Sub");<br style="word-wrap:break-word">
}<br style="word-wrap:break-word">}
复制代码
2。对象的创建（creation of new class instances），稍微有点烦琐，具体的步骤如下
(a) 所有的成员变量—包括该类，及它的父类中的成员变量--被分配内存空间，并赋予默认值。（Btw，这里是第一次初始化成员变量）
(b) 为所调用的构造函数初始化其参数变量。（如果有参数）
(c) 如果在构造函数中用this 调用了同类中的其他构造函数，则按照步骤(b)~(f)去处理被调用到的构造函数。
(d) 如果在构造函数中用super调用了其父类的构造函数，则按照步骤(b)~(f)去处理被调用到的父类构造函数。
(e) 按照书写顺序，执行instance initializer 和 instance variable initializer来初始化成员变量。（Btw，这里是第二次初始化成员变量）
(f) 按照书写顺序，执行constructor的其余部分。
注意
成员变量其实都被初始化2次，第一次是赋予默认值，第二次才是你想要设定的值。
最后看一个例子：
public class InitializationOrder {
public static void main(String[] args) {<br style="word-wrap:break-word">
Subclass sb = new Subclass();<br style="word-wrap:break-word">
}<br style="word-wrap:break-word">}
class Super{
<br style="word-wrap:break-word">
static {<br style="word-wrap:break-word">
System.out.println(1);<br style="word-wrap:break-word">
}<br style="word-wrap:break-word">
<br style="word-wrap:break-word">
Super(int i){<br style="word-wrap:break-word">
System.out.println(i);<br style="word-wrap:break-word">
}<br style="word-wrap:break-word">}
class Subclass extends Super implements Interface{
<br style="word-wrap:break-word">
static {<br style="word-wrap:break-word">
System.out.println(2);<br style="word-wrap:break-word">
} <br style="word-wrap:break-word">
<br style="word-wrap:break-word">
Super su = new Super(4);<br style="word-wrap:break-word">
<br style="word-wrap:break-word">
Subclass() {<br style="word-wrap:break-word">
super(3);<br style="word-wrap:break-word">
new Super(5);<br style="word-wrap:break-word">
}<br style="word-wrap:break-word">}
interface Interface{
static Super su = new Super(0);<br style="word-wrap:break-word">}
复制代码
稍微解释一下：
首先，Java虚拟机要执行InitializationOrder类中的static
方法main()，这引起了类的初始化。开始初始化InitializationOrder类。具体的步骤略去不说。
接着，InitializationOrder类初始化完毕后，开始执行main()方法。语句Subclass sb = new Subclass()将创建一个Subclass对象。加载类Subclass后对其进行类初始化，但因为Subclass有一个父类Super，所以先初始化Super类，初始化块static {System.out.println(1);}被执行，打印输出1；
第三，Super初始化完毕后，开始初始化Subclass类。static {System.out.println(2);}被执行，打印输出2；
第四，至此，类的加载工作全部完成。开始进入创建Subclass的对象过程。先为Subclass类和其父类Super类分配内存空间，这时Super su 被附值为null;
第五，执行构造函数Subclass()时，super(3)被执行。如前面(d)所说，Super类的构造函数Super(int i){….}被调用，并按照步骤(b)~(f)来处理。因此，递归调用Super类的父类Object类的构造函数，并按照步骤(b)~(f)来初始化Object类，不过没有任何输入结果。最后打印输出3；
第六，如前面(e)所说，初始化成员变量su，其结果是打印输出4；
第七，如前面(f)所说，执行new Super(5)，并打印输出5；
最后，Subclass虽然实现了接口Interface，但是初始化它的时候并不会引起接口的初始化，所以接口Interface中的static Super su = new Super(0)自始至终都没有被执行到。
① 类属性 (静态变量) 定义时的初始化，如上例的 static String a = "string-a";
② static 块中的初始化代码，如上例 static {} 中的 b = "string-b";
③ 对象属性 (非静态变量) 定义时的初始化，如上例的 String c = "stirng-c";
④ 构造方法 (函数) 中的初始化代码，如上例构造方法中的 d = "string-d";