Java类中，各成员初始化顺序

1.静态属性：static 开头定义的属性
2.静态方法块： static {} 圈起来的方法块
3.普通属性： 未带static定义的属性
4.普通方法块： {} 圈起来的方法块
5.构造函数： 类名相同的方法
6.方法： 普通方法

子类初始化：

1. 父类静态属性
2. 父类静态方法块
3. 子类静态属性
4. 子类静态方法块
5. 父类普通属性
6. 父类普通方法块
7. 父类构造函数
8. 子类普通属性
9. 子类普通方法块
10. 子类构造函数

package com.hhu;
 
public class ClassInit {
 
    public static void main(String[] args) {
        LifeCycle a = new LifeCycle();
        System.out.println(a.a);
        System.out.println(a.b);
        System.out.println(a.c);
        /*父类静态属性初始化
        父类静态方法块初始化
        Static Field Initial
        0
        父类普通属性初始化
        父类普通方法块初始化
        Field Initial
        0
        0
        父类构造函数初始化
        0
        2
        3*/
        
        LifeCycle lc=new LifeCycleChild();
        /*父类静态属性初始化
        父类静态方法块初始化
        Static Field Initial
        0
        子类静态属性初始化
        子类静态方法块初始化
        Child Static Field Initial
        1
        父类普通属性初始化
        父类普通方法块初始化
        Field Initial
        0
        0
        父类构造函数初始化
        子类普通属性初始化
        子类普通方法块初始化
        Child Field Initial
        0
        0
        子类构造函数初始化*/
        LifeCycleChild lcc=new LifeCycleChild();
        System.out.println(lcc.bc);
        System.out.println(lcc.cc);
        /*父类静态属性初始化
        父类静态方法块初始化
        Static Field Initial
        0
        子类静态属性初始化
        子类静态方法块初始化
        Child Static Field Initial
        1
        父类普通属性初始化
        父类普通方法块初始化
        Field Initial
        0
        0
        父类构造函数初始化
        子类普通属性初始化
        子类普通方法块初始化
        Child Field Initial
        0
        0
        子类构造函数初始化
        4
        6*/
    }
 
}
 
class LifeCycle {
    // 静态属性
    public static String staticField = getStaticField();
    public static final Integer a = 0;
    // 静态方法块
    static {
        System.out.println("父类静态方法块初始化");
        System.out.println(staticField);
        System.out.println(a);
    }
    // 普通属性
    public String field = getField();
    public int b;
    public int c;
 
    // 普通方法块
    {
        System.out.println("父类普通方法块初始化");
        System.out.println(field);
        System.out.println(b);
        System.out.println(c);
    }
 
    // 构造函数
    public LifeCycle() {
        System.out.println("父类构造函数初始化");
        b = c + 2;
        c = 3;
    }
 
    public static String getStaticField() {
        String statiFiled = "Static Field Initial";
        System.out.println("父类静态属性初始化");
        return statiFiled;
    }
 
    public static String getField() {
        String filed = "Field Initial";
        System.out.println("父类普通属性初始化");
        return filed;
    }
}
 
class LifeCycleChild extends LifeCycle {
    // 静态属性
    public static String staticFieldchild = getStaticFieldChild();
    public static final Integer ac = 1;
    // 静态方法块
    static {
        System.out.println("子类静态方法块初始化");
        System.out.println(staticFieldchild);
        System.out.println(ac);
    }
    // 普通属性
    public String fieldchild = getFieldChild();
    public int bc;
    public int cc;
 
    // 普通方法块
    {
        System.out.println("子类普通方法块初始化");
        System.out.println(fieldchild);
        System.out.println(bc);
        System.out.println(cc);
    }
 
    // 构造函数
    public LifeCycleChild() {
        System.out.println("子类构造函数初始化");
        bc = cc + 4;
        cc = 6;
    }
 
    public static String getStaticFieldChild() {
        String statiFiled = "Child Static Field Initial";
        System.out.println("子类静态属性初始化");
        return statiFiled;
    }
 
    public static String getFieldChild() {
        String filed = "Child Field Initial";
        System.out.println("子类普通属性初始化");
        return filed;
    }
}

Plus: http://www.danielschneller.com/2010/07/java-object-initialization-order-know.html

package com.hhu;
 
public class Lower extends Upper {
 
 String lowerString = null;
 
 public Lower() {
  super();
  System.out.println("Upper:  " + upperString);
  System.out.println("Lower:  " + lowerString);
 }
 
 public static void main(final String[] args) {
  new Lower();
 }
}
 
class Upper {
 String upperString;
 
 public Upper() {
  Initializer.initialize(this);
 }
}
 
class Initializer {
 static void initialize(final Upper anUpper) {
  if (anUpper instanceof Lower) {
   Lower lower = (Lower) anUpper;
   lower.lowerString = "lowerInited";
  }
  anUpper.upperString = "upperInited";
 }
结果：

Upper:  upperInited
Lower:  null;
public class Lower extends Upper {
 
 String lowerString;//修改这里
 
 public Lower() {
  super();
  System.out.println("Upper:  " + upperString);
  System.out.println("Lower:  " + lowerString);
 }
 
 public static void main(final String[] args) {
  new Lower();
 }
}
结果：

Upper:  upperInited
Lower:  lowerInited

原理：

new Lower()后，一个Lower的实例被创建，并在栈上分配内存，用于hold成员变量。
所有成员变量被初始化为默认值。
从父到子，依次调用构造函数。
Upper的实例被创建，所有的初始化器被调用，同上。
Initializer.initialize(this);被调用。
this为（com.hhu.Lower@7852e922）。
lowerString=lowerInited，upperString=upperInited，父类构造函数结束。
Lower的构造函数被调用，执行了（StringlowerString ;或者=null）此处就（不用）或者（用）null值覆盖已经被赋的lowerInited。
但是如果声明为静态变量：static String lowerString;和 =null;和=“example”;的结果都是lowerInited

原理：静态成员变量在类被加载到jvm后，已经初始化了（如果是static final，在类加载的准备阶段初始化；如果只是static，在类加载的初始化阶段；都早于构造函数的执行），所以lowerString的初始值是Lower类中声明的值，后被Initializer.initialize赋值。