一、变量与构造器的初始化顺序
我们知道一个类中具有类变量、类方法和构造器（方法中的局部变量不讨论，他们是在方法调用时才被初始化），当我们初始化创建一个类对象时，其初始化的顺序为：先初始化类变量，再执行构造器方法。
代码验证：
public class Demo01 {
public int a1 = 1;
public String a2 = "initiaied!";
public Demo01() {
System.out.println(a1);
System.out.println(a2);
System.out.println("构造器方法被执行");
}
public static void main(String【】 args) {
Demo01 demo01 = new Demo01();
}//代码效果参考：http://www.ezhiqi.com/bx/art_6913.html
}
运行结果：
1
initiaied!
构造器方法被执行
可以看出，当我们创建一个Demo01对象时，先初始化了变量a1和a2，然后执行构造器方法。
二、静态变量与非静态变量的初始化顺序
静态变量是属于类本身，无论创建多少个对象，静态变量都只有一份存储区域，因此他会在类首次被访问或者首次创建类对象时被初始化，而且有且只能初始化一次。
而非静态变量是属于每个对象，他是在创建每个对象时都初始化一次。因此，静态变量要先于非静态进行初始化。例子：
public class Demo02 {
public Cup cup1 = new Cup(1);
public static Cup cup2 = new Cup(2);
public Demo02() {
System.out.println("Demo02构造器被执行！");
}
public static void main(String【】 args) {
Demo02 demo02 = new Demo02();
Demo02 demo02_01 = new Demo02();
}
}
class Cup {
public Cup(int i) {
System.out.println("Cup->" + i);
}
}
运行结果：
Cup->2
Cup->1
Demo02构造器被执行！
Cup->1
Demo02构造器被执行
当程序要执行main方法时，会先加载Demo02类文件，在加载时就会先初始化静态变量cup2，因此控制台输出"cup->2"。
类加载完后，开始执行main方法，创建demo02对象，这时就会初始化类中的非静态变量cup1，控制台输出"cup->1"，然后执行构造器方法。创建第二个对象时，只初始化cup1，cup2为静态变量只初始化一次。
三、静态代码块与非静态代码块
静态代码块本质上就是一段静态变量的代码，其初始化和静态变量没有区别：当类首次被访问或者首次创建该类对象时被初始化，并且只初始化一次。
非静态代码块就是一段非静态变量的代码，他和非静态变量的初始化没有区别。
public class Demo03 {
static Table table1;
Table table2;
static {
table1 = new Table(1);
}
{
table2 = new Table(2);
}//代码效果参考：http://www.ezhiqi.com/zx/art_5018.html
public Demo03() {
System.out.println("Demo03构造器被执行");
}
public static void main(String【】 args) {
new Demo03();
}
}//代码效果参考：http://www.ezhiqi.com/bx/art_701.html
class Table {
public Table(int i) {
System.out.println("Table->" + i);
}
}
运行结果：
Table->1
Table->2
Demo03构造器被执行
四、父类与子类的初始化顺序
没有父类就没有子类，因此无论是类加载还是创建实例对象，父类都优先于子类进行初始化。
public class Demo04 extends Insect {
private int k = fun("Demo04中的k被初始化");
private static int x2 = fun("Demo04中的x2被初始化");
public Demo04() {
System.out.println("k=" + k);
System.out.println("j=" + j);
}
public static void main(String【】 args) {
Demo04 demo04 = new Demo04();
}
}
class Insect {
public int i = 9;
public int j;
public static int x1 = fun("Insect中的x1被初始化");
public Insect() {
System.out.println("i=" + i + ",j=" + j);
j = 39;
}
public static int fun(String s) {
System.out.println(s);
return 47;
}
}
运行结果：
Insect中的x1被初始化
Demo04中的x2被初始化
i=9,j=0
Demo04中的k被初始化
k=47
j=39
当执行main方法时，加载器开始加载Demo04类文件，在加载过程中，加载器会注意到他有一个父类Insect还没被加载，因此会先加载父类Insect文件。
类加载过程中会完成静态变量的初始化(此时并不执行构造器方法，构造器方法只有在创建对象时调用)，Insect类加载完成后，接着加载Demo04类，都加载完成后，就开始执行main方法中的代码，创建Demo04对象。
由于继承关系，因此先创建父类Insect的实例对象，因此父类中的变量初始化和构造器先被执行，然后在初始化子类Demo04中的非静态变量和执行构造器方法。
五、总结
最后放一段代码，把前面所说情况都放在一起。
public class Son extends Father {
int m = fun("Son中的m 被初始化");
public Son() {
System.out.println("m = " + m);
System.out.println("j = " + j);
}
public static int x3 = fun("Son中的x3 被初始化");
public static void main(String【】 args) {
Son son = new Son();
}
}
class Father extends GrandFather {
public int k = fun("Father中的k被初始化");
public static int x2 = fun("Father中的x2被初始化");
public Father() {
System.out.println("k=" + k);
System.out.println("j=" + j);
}
}
class GrandFather {
public int i = 9;
public int j;
public static int x1 = fun("GrandFather中的x1被初始化");
public GrandFather() {
System.out.println("i=" + i + ",j=" + j);
j = 39;
}
public static int fun(String s) {
System.out.println(s);
return 47;
}
}
运行结果：
GrandFather中的x1被初始化
Father中的x2被初始化
Son中的x3 被初始化
i=9,j=0
Father中的k被初始化
k=47
j=39
Son中的m 被初始化
m = 47
j = 39
