类初始化顺序

/*
*
* 类初始化顺序
*
* 1. 静态构造块最先执行，并只执行一次
* 2. 成员变量执行，但静态成员变量早于静态块执行
* 3. 构造块从上至下依次执行
* 4. 构造方法执行
*
*  父类早于子类
*
*  父类静态构造块--》子类静态构造块--》父类成员变量--》父类构造块--》父类构造方法--》子类成员变量--》子类构造块--》子类构造方法
*
*  静态成员变量先于静态块执行
*
*
*  首先执行父类静态的内容，父类静态的内容执行完毕后，接着去执行子类的静态的内容，
*  当子类的静态内容执行完毕之后，再去看父类有没有构造代码块，如果有就执行父类的构造代码块，
*  父类的构造代码块执行完毕，接着执行父类的构造方法；父类的构造方法执行完毕之后，它接着去看子类有没有构造代码块，
*  如果有就执行子类的构造代码块。子类的构造代码块执行完毕再去执行子类的构造方法。

　　总之一句话，静态代码块内容先执行，接着执行父类构造代码块和构造方法，然后执行子类构造代码块和构造方法。
* */


public class Test3 {

    public static void main(String[] args) {
        new B();
        System.out.println("=============");
        new B();
        System.out.println("+++++++++++++++");
        new A();

        /*
        *
        * 猜测的执行结果：
        *
        * A 的静态构造块
        * A 的构造块1
        * A 的构造块2
        * D 的静态构造块
        * D 的构造块
        * D 的静态方法
        * A 的构造方法
        * B 的静态构造块
        * B 的造块
        * B 的静态构
        * C 的静态构造块
        * C 的构造块
        * C 的构造方法
        * D 的构造块
        * D 的构造方法
        * B 的构造方法
        *
        * =============
        *
        * A 的构造块1
        * A 的构造块2
        * D 的构造块
        * D 的静态方法
        * A 的构造方法
        * B 的造块
        * B 的静态构
        * C 的构造块
        * C 的构造方法
        * D 的构造块
        * D 的构造方法
        * B 的构造方法
        *
        * ++++++++++++++
        *
        * A 的构造块
        * D 的构造块
        * D 的构造方法
        * A 的构造方法
        * */
    }

}


class A{

    private static C c = new C();
    private D d = new D();

    {
        System.out.println("A 的构造块1");
    }

    static {
        System.out.println("A 的静态构造块");
    }

    A(){
        System.out.println("A 的构造方法");
    }

    {
        System.out.println("A 的构造块2");
    }

}

class B extends A{

    private C c = new C();

    //public static D d = new D();
    public static D d;

    B(){
        System.out.println("B 的构造方法");
    }

    {
        System.out.println("B 的构造块");
    }

    static {
        System.out.println("B 的静态构造块");
    }

}

class C{

    C(){
        System.out.println("C的构造函数");
    }

    {
        System.out.println("C 的构造块");
    }

    static {
        System.out.println("C 的静态构造块");
    }

}

class D{

    D(){
        System.out.println("D 的构造函数");
    }

    {
        System.out.println("D 的构造块");
    }

    static {
        System.out.println("D 的静态构造块");
    }

}