Java类的加载顺序

Java构造函数，构造代码块，静态代码块的区别和调用时间

public class Constructor {

    public static void main(String[] args) {
        System.out.println("创建第一个对象：");
        Test test1 = new Test();
        System.out.println("");
        System.out.println("创建第二个对象：");
        Test test2 = new Test(5);
    }
}

class Test {
    // 静态代码块1
    static {
        System.out.println("我是静态代码块1");
    }
    // 构造代码块1：
    {
        System.out.println("我是构造代码块1");
    }

    // 构造函数1
    public Test() {
        System.out.println("我是无参构造函数");
    }

    // 构造函数2
    public Test(int t) {
        System.out.println("我是带参构造函数，" + "参数是" + t);
    }

    // 静态代码块2
    static {
        System.out.println("我是静态代码块2");
    }

    // 构造代码块2：
    {
        System.out.println("我是构造代码块2");
    }
}

创建第一个对象：
我是静态代码块1
我是静态代码块2
我是构造代码块1
我是构造代码块2
我是无参构造函数

创建第二个对象：
我是构造代码块1
我是构造代码块2
我是带参构造函数，参数是5

执行时间：静态代码块>构造代码块>构造函数

静态代码块只会在类被载入内存时加载一次，构造代码块和构造函数都是在对象创建的时候执行，有几个对象就会执行几次，所以一般将加载配置文件的过程写在静态代码块中

无继承类的加载顺序

public class Parameter {

    public Parameter(String str) {
        System.out.println(str);
    }
}

public class Test1 {

    public static Parameter parameter1 = new Parameter("静态成员变量");

    public Parameter parameter2 = new Parameter("非静态成员变量");

    public Test1() {
        System.out.println("构造函数");
    }

    static {
        System.out.println("静态代码块");
    }

    {
        System.out.println("构造代码块a");
    }

    {
        System.out.println("构造代码块b");
    }

    public static void main(String[] args) {
        /*
          静态成员变量
          静态代码块
          非静态成员变量
          构造代码块a
          构造代码块b
          构造函数
        */
        new Test1();
        System.out.println();
        /*
          非静态成员变量 
          构造代码块a
          构造代码块b
          构造函数
        */
        new Test1();
    }

}

可以看到静态成员变量和静态代码块一样，只会在类被载入内存时加载一次

public class Test2 {

    static {
        System.out.println("静态代码块");
    }

    public Test2() {
        System.out.println("构造函数");
    }

    {
        System.out.println("构造代码块b");
    }

    {
        System.out.println("构造代码块a");
    }

    public static Parameter parameter1 = new Parameter("静态成员变量");

    public Parameter parameter2 = new Parameter("非静态成员变量");

    public static void main(String[] args) {
        /*
          静态代码块
          静态成员变量
          构造代码块b
          构造代码块a
          非静态成员变量
          构造函数
        */
        new Test2();
    }

}

执行顺序（静态函数在调用时被加载）

1. 静态代码块和静态成员变量，加载顺序由编写顺序决定
2. 构造代码块和非静态成员变量，加载顺序由编写顺序决定
3. 构造函数

有继承类的加载顺序

public class Father {

    public static Parameter parameter1 = new Parameter("父类静态成员变量");

    public Parameter parameter2 = new Parameter("父类非静态成员变量");

    public Father() {
        System.out.println("父类的构造函数");
    }
}

public class Son extends Father{

    public static Parameter parameter1 = new Parameter("子类静态成员变量");

    public Parameter parameter2 = new Parameter("子类非静态成员变量");

    public Son() {
        System.out.println("子类的构造函数");
    }

    public static void main(String[] args) {
        /*
          父类静态成员变量
          子类静态成员变量
          父类非静态成员变量
          父类的构造函数
          子类非静态成员变量
          子类的构造函数
        */
        new Son();
    }
}

执行顺序
1. 父类的静态（静态代码块，静态成员变量），子类的静态（静态代码块，静态成员变量）
2. 父类的非静态（构造代码块，非静态成员变量），父类的构造函数
3. 子类的非静态（构造代码块，非静态成员变量），子类的构造函数

参考博客

构造函数执行时间
[4]https://www.cnblogs.com/zavierliu/p/7599208.html
[5]http://www.cnblogs.com/mjyung/p/6708230.html
[6]https://www.cnblogs.com/xyczero/p/4002786.html
[7]https://www.cnblogs.com/SirSmith/p/5536288.html
java类记载的顺序
[1]https://www.cnblogs.com/SirSmith/p/5536288.html
[2]http://blog.csdn.net/mrzhoug/article/details/51581994