[Java] Java继承关系中 父类静态块 子类静态块 构造函数的调用顺序

父类和子类的代码

package test;

public class Parent {

    static {
        System.out.println("父类静态块.");
    }

    public Parent() {
        System.out.println("父类构造函数: 0 参数.");
    }

    public Parent(String str) {
        System.out.println("父类构造函数: 1 参数."+str);
    }
}

class Son extends Parent{
    static {
        System.out.println("子类静态块.");
    }

    public Son() {
        System.out.println("子类构造函数: 0 参数.");
    }
    public Son(String str) {
        System.out.println("子类构造函数: 1 参数."+ str);
    }
}

main函数

 public static void main(String[] args) {
        System.out.println("Parent parent0 =  new Son() 的输出结果:");
        Parent parent0 =  new Son();


        System.out.println("\n\nSon son0 = new Son() 的输出结果:");
        Son son0 = new Son();

        System.out.println("\n\nParent parent = new Son(\"一个参数的向上转型\") 的输出结果:");
        Parent parent1 = new Son("一个参数的向上转型");

        System.out.println("\n\nSon son = new Son(\"一个参数的没有转型\") 的输出结果:");
        Son son = new Son("一个参数的没有转型");

        System.out.println("\n\nParent parent = new Parent(\"一个父类的实例\")");
        Parent parent2 = new Parent("一个父类的实例");
    }

输出结果

Parent parent0 =  new Son() 的输出结果:
父类静态块.
子类静态块.
父类构造函数: 0 参数.
子类构造函数: 0 参数.


Son son0 = new Son() 的输出结果:
父类静态块.
子类静态块.
父类构造函数: 0 参数.
子类构造函数: 0 参数.


Parent parent = new Son("一个参数的向上转型") 的输出结果:
父类静态块.
子类静态块.
父类构造函数: 0 参数.
子类构造函数: 1 参数.一个参数的向上转型


Son son = new Son("一个参数的没有转型") 的输出结果:
父类静态块.
子类静态块.
父类构造函数: 0 参数.
子类构造函数: 1 参数.一个参数的没有转型


Parent parent = new Parent("一个父类的实例")
父类静态块.
父类构造函数: 1 参数.一个父类的实例

总结

用一句话来描述: 除了直接new父类的情况,都会遵循以下规则:
父类静态块->子类静态块->父类无参构造器->子类构造器(有参数则调用对应的有参构造器)

PS:以上的输出结果是分个得出来的, 如果一起运行,那么只会在第一种情况下输出:
父类静态块.
子类静态块.
这是因为JVM保证被static修饰的代码块或者变量在一次编译中只执行一次