类的初始化顺序

类的初始化：在类链接的准备阶段时，类属性会被赋予默认值；类链接阶段之后，类属性赋值和静态代码块才会被执行（类初始化）。

现在探究类继承链上的类属性赋值和静态代码块的执行顺序？

预期了解

初始化顺序，静态代码块和静态属性（按自上而下的排列顺序）；
如果父类没有被初始化，就会先初始化父类，初始化完父类，才会轮到自己；

注：

由 final 修饰的静态属性，只有使用 new 关键字赋值, 才会触发类的初始化（只是属性特例，方法没影响）

// new 关键字 触发 类的初始化
static final Object obj = new Object();
// 不触发 类的初始化
static final int count = 1;

静态内部类的初始化不会触发外部类的初始化

测试

注：测试类必须另外创建，因为 JVM 会首先加载和初始化主类（有 main 方法的类）

public class Children extends Parent{
    // 静态代码块
    static {
        System.out.println("初始化子类的静态代码块");
    }
    // 普通静态属性
    public static Option2 option = new Option2();
    // final 静态属性
    // 使用 new 关键字
    public static final Object newFinalObj = new Object();
    // 不是用 new 关键字
    public static final int finalCount = 1;
    // 普通静态方法
    public static String test1(){
        System.out.println("调用子类的 普通静态方法");
        return "";
    }
    // final 静态方法
    public static final String finalMethod(){
        System.out.println("调用子类的 final的静态方法");
        return "";
    }

    static class StaticInClass{
        public static Option1 option = new Option1();
        // final 静态属性
        // 使用 new 关键字
        public static final Object newFinalObj = new Object();
        // 不是用 new 关键字
        public static final int finalCount = 1;
        // 静态代码块
        static {
            System.out.println("初始化子类的静态内部类的静态代码块");
        }
        // 普通静态方法
        public static String test1(){
            System.out.println("调用子类的静态内部类的 普通静态方法");
            return "";
        }
        // final 静态方法
        public static final String finalMethod(){
            System.out.println("调用子类的静态内部类的 final的静态方法");
            return "";
        }
    }
}
class Option1{
    static {
        System.out.println("初始化子类的静态内部类的静态属性");
    }
}
class Option2{
    static {
        System.out.println("初始化子类的静态属性");
    }
}

public class Parent {
    // 静态代码块
    static {
        System.out.println("初始化父类的静态代码块");
    }
    // 普通静态属性
    public static Option0 option = new Option0();
    // final 静态属性
    // 使用 new 关键字
    public static final Object newFinalObj = new Object();
    // 不是用 new 关键字
    public static final int finalCount = 1;
    // 普通静态方法
    public static String test1(){
        System.out.println("调用父类的 普通静态方法");
        return "";
    }
    // final 静态方法
    public static final String finalMethod0(){
        System.out.println("调用父类的 final的静态方法");
        return "";
    }
}
class Option0{
    static {
        System.out.println("初始化父类的静态属性");
    }
}
public class Test {
    public static void main(String[] args) {
        // 测试本类
        // System.out.println(Children.option);
        // System.out.println(Children.newFinalObj);
        // System.out.println(Children.finalCount);
        // System.out.println(Children.finalMethod());
        // System.out.println(Children.test1());

        // 测试静态内部类
        // System.out.println(Children.StaticInClass.option);
        // System.out.println(Children.StaticInClass.finalCount);
        // System.out.println(Children.StaticInClass.newFinalObj);
        // System.out.println(Children.StaticInClass.finalMethod());
        // System.out.println(Children.StaticInClass.test1());

        // 测试 继承链的
        // System.out.println(Children.newFinalObj);
    }
}