Java - 详细分析 【类初始化】 和 【实例初始化】 的过程及顺序

概述

到目前为止，我也接触 Java 有 7 年左右的时间了，我认为对 Java 基础的了解程度，会直接影响到你对 Java 相关的框架以及中间件的了解程度。以 Spring 为代表，作为最流行的 Java 框架，Spring 底层无处不在使用着 Java 的 封装、继承、多态、泛型、反射、类加载机制 等特性，所以 Spring 框架是一个非常值得我们 Java 程序员一读再读的好框架，在 spring 学习专栏 中，我也记录了阅读 Spring 源码的一些笔记，感兴趣的朋友可以看一下。

前言

在这篇文章中，我们主要来了解一下 Java 中的 类加载时机、类初始化顺序 和 实例初始化顺序。在正式开始之前，我们需要回顾一下 Java - static 关键字，我们知道 static 修饰的属性或者方法，都是跟 类 相关联的，会随着类的加载而被加载，而不是随着对象的初始化被加载。

举例

下面我们通过一个例子来直观的看一下：

• 定义一个父类 Father

public class Father {

    private int i = test();

    static {
        System.out.print("(1)");
    }

    private static int j = method();

    Father() {
        System.out.print("(2)");
    }

    {
        System.out.print("(3)");
    }

    public int test() {
        System.out.print("(4)");
        return 1;
    }

    public static int method() {
        System.out.print("(5)");
        return 1;
    }
}

• 定义一个子类 Som

public class Son extends Father {

    private int i = test();

    private static int j = method();

    static {
        System.out.print("(6)");
    }

    Son() {
        System.out.print("(7)");
    }

    {
        System.out.print("(8)");
    }

    @Override
    public int test() {
        System.out.print("(9)");
        return 1;
    }

    public static int method() {
        System.out.print("(10)");
        return 1;
    }

    public static void main(String[] args) {
        Son s1 = new Son();
        System.out.println();
        Son s2 = new Son();
    }
}

输出结果放在文章末尾，这里可以先思考一下，上面的 main 方法最终会输出什么？

分析

在 《深入理解 JAVA 虚拟机》 这本书中的第 7 章：虚拟机类加载机制 中有提到（摘选部分内容，感兴趣的可以查看相关书籍）：

1. 当虚拟机启动时，虚拟机会先初始化 main() 方法所在的类（主类）
2. 当初始化类的时候，如果发现其父类还没有进行过初始化，则需要先触发其父类的初始化
3. 遇到以下 3 种情形，如果类还没有初始化，需要先触发其初始化：
   • 使用 new 关键字实例化对象的时候
   • 读取或设置一个类的静态字段（被 final 修饰、已在编译期把结果放入常量池的静态字段除外）的时候
   • 调用一个类的静态方法的时候
4. 类的初始化是执行 <clinit>() 方法，实例的初始化是执行 <init>() 方法
5. <clinit>() 方法的执行顺序是 语句在源文件中出现的顺序（也就是类的初始化顺序）
6. <clinit>() 方法只会执行一次
7. <init>() 方法可能重载有多个，有几个构造器就有几个 <init>() 方法。<init>() 方法由非静态实例变量显示赋值代码和非静态代码块、对应的构造器代码组成。非静态实例变量显示赋值代码和非静态代码块从上到下顺序执行，构造器代码最后执行
8. 每次创建对象，都会执行对应的构造器，也就是 <init>() 方法可能会执行多次
9. 子类如果重写了父类的方法，通过子类对象调用的一定是子类重写过的代码

---

1、第一步会执行 main() 方法，所以此时会首先初始化 Son 类
2、初始化 Son 类的时候，发现存在父类 Father，所以需要先初始化 Father
3、初始类的时候，只有被 static 修改的 属性 或 代码块 才会执行，所以这一步会输出：（1）（5）
4、初始化完父类，才会初始化子类 Son，此时会输出：（10）（6）
5、在还没有开始执行 main() 方法里面的内容之前，Java 的类加载机制执行了以上内容
6、接着会执行 main() 方法里面的第一行代码 Son s1 = new Son()，这里使用 new 来实例化一个对象，所以会触发 Son 类的初始化，但是 Son 在上面已经初始化过，所以不再初始化
7、执行 Son 的实例化过程（调用无参构造方法），因为 Son 有父类，所以 Son 的无参构造方法第一行应该为 super()，调用父类的无参构造方法来实例化父类
8、实例化 Father 对象，首先会执行：

private int i = test();

// 调用方法前面会有一个 this.，相当于
private int i = this.test()

// this 表示当前正在创建的对象，也就是 son

会输出：（9）（3）（2）
9、接着实例化 Son 对象，输出：（9）（8）（7）
10、第 2 次创建 Son 对象，除了类的初始化不用执行，父类和子类的实例初始化都要再执行一次，所以再次输出：（9）（3）（2）（9）（8）（7）

总结

虽然看起来是一个很小的知识点，但是涉及到的概念还是比较多的，也是 Java 语言中程序员能接触到的底层（接触不到的就是虚拟机为我们做的那些处理字节码的事情），所以虽然比较难理解，但是还是要掌握，不行了就多看几遍。

以上内容有什么不对的地方，欢迎大家评论区留言指正 [感谢][感谢][撒花][撒花]

• 输出结果

(1)(5)(10)(6)(9)(3)(2)(9)(8)(7)
(9)(3)(2)(9)(8)(7)