构造器执行顺序Java

先说结论：父类静态代码块>子类静态代码块>父类的构造代码块>父类的构造函数>子类构造代码块>子类构造函数

举个例子：

public class HelloB extends HelloA {
    public HelloB(){
        System.out.println(" HelloB constructor");
    }
    {
        System.out.println("helloa 构造器");//构造代码块
    }
    static {
        System.out.println("static B");
    }

    public static void main(String[] args) {
       // new HelloB();
    }
}
class HelloA{
    public HelloA(){
        System.out.println(" HelloA constructor");
    }
    {
        System.out.println("helloa 构造器");
    }
    static {
        System.out.println("static A");
    }
}

在主函数里面啥也不做，运行结果如下。这是因为，static是在类加载的时候就执行了。

static A
static B

将主函数注释去掉，得到的结果为：

static A
static B
helloa 构造器
 HelloA constructor
helloa 构造器
 HelloB constructor

可以看出：先执行父类和子类的static静态代码块，然后执行父类的构造器代码块和父类的构造函数，最后才是子类。规律就是：先执行父类，在执行子类（这是因为子类是父类的延申，父类都没有，何谈子类，所以先执行父类），构造函数的执行顺序靠最后。
再举个例子：

class Insect {
    int i = 9;
    int j;
    Insect() {
        prt("i = " + i + ", j = " + j);
        j = 39;
    }
    static int x1 =
            prt("static Insect.x1 initialized");
    static int prt(String s) {
        System.out.println(s);
        return 47;
    }
}
public class Beetle extends Insect {
    int k = prt("Beetle.k initialized");
    Beetle() {
        prt("k = " + k);
        prt("j = " + j);
    }
    static int x2 = prt("static Beetle.x2 initialized");
    static int prt(String s) {
        System.out.println(s);
        return 63;
    }
    public static void main(String[] args) {
      Beetle b = new Beetle();
    }
}

结果：

static Insect.x1 initialized
static Beetle.x2 initialized
i = 9, j = 0
Beetle.k initialized
k = 63
j = 39

对Beetle 运行Java 时，发生的第一件事情是装载程序到外面找到那个类。在装载过程中，装载程序注意它有一个基础类（即 extends 关键字要表达的意思），所以随之将其载入。无论是否准备生成那个基础类的一个对象，这个过程都会发生（请试着将对象的创建代码当作注释标注出来，自己去证实）。
若基础类含有另一个基础类，则另一个基础类随即也会载入，以此类推。接下来，会在根基础类（此时是Insect）执行 static 初始化，再在下一个衍生类执行，以此类推。保证这个顺序是非常关键的，因为衍生类的初始化可能要依赖于对基础类成员的正确初始化。
此时，必要的类已全部装载完毕，所以能够创建对象。首先，这个对象中的所有基本数据类型都会设成它们的默认值，而将对象句柄设为 null。随后会调用基础类构建器。在这种情况下，调用是自动进行的。但也完全可以用super 来自行指定构建器调用（就象在Beetle()构建器中的第一个操作一样）。基础类的构建采用与衍生类构建器完全相同的处理过程。基础顺构建器完成以后，实例变量会按本来的顺序得以初始化。最后，执行构建器剩余的主体部分。