Java类中各模块的加载顺序的JVM本质理解

最新推荐文章于 2025-07-08 19:52:33 发布

卡夫卡的卡夫饼干

最新推荐文章于 2025-07-08 19:52:33 发布

阅读量3.1k

点赞数 4

CC 4.0 BY-SA版权

分类专栏： java-se 文章标签： java jvm

本文链接：https://blog.youkuaiyun.com/wzw9353/article/details/74892149

java-se 专栏收录该内容

5 篇文章

订阅专栏

本文详细解析了Java类加载过程中的静态与非静态代码块的执行顺序，通过具体实例阐述了JVM如何处理类和对象的初始化过程。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

Java类中各模块的加载顺序只是表象，但至于为什么我们需要理解JVM的加载本质原理。

话不多说，上代码，从分析代码开始：

public class Test1 {

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

    {
        System.out.println("这是普通代码块");
    }

    public static void method(){
        System.out.println("这是一个静态方法");
    }

    public void method2(){
        System.out.println("这是一个普通方法");
    }

    public Test1(){
        System.out.println("这是一个无参构造方法");
    }


    public static void main(String[] args) {

    }

}

运行结果为：

这是静态代码块

分析如下：
首先，JVM在加载类的时候先找一个类的main()方法，这也是一个类的入口，如果没有main()方法，这个类将无法执行。所以main()方法是类加载的前提。但是不是说，有了main()方法就必须先执行main()方法里面的代码，这是大错特错的，就比如说你去打扫一个房间，房间的门牌号是你找到房间的前提。但是找到房间后并不是要先打扫门口的位置。
找到main()方法后，JVM开始初始化类，而static修饰的代码块，是根据类加载而加载的，并且只会加载依次，下次再加载这个类时，因为类已经被加载过了，所以static代码块也已经加载过了，所以不会再次执行static代码块。而普通代码块和构造方法是与对象有关的，而所有的代码都没有对象的产生，所以也不会执行这些代码，所以非静态代码全都没有执行。虽然有被静态修饰的方法，但是方法不调用不执行，所以输出结果里没有方法的结果。

我们接着尝试创建对象：

代码如下：

public static void main(String[] args) {
        Test1 t=new Test1();

    }

程序运行结果如下：

这是静态代码块
这是普通代码块
这是一个无参构造方法

分析如下：
正如我们上面说的那样，JVM在找到main方法后，开始初始化类，执行静态代码块，然后回到main()方法，执行main()方法里面的代码，创建对象后，程序中的非静态代码块和构造方法相继执行，完成后回到main()方法，再执行main()方法下面的程序，我们可以修改下main()方法验证下。

main（）方法如下：

    public static void main(String[] args) {
        System.out.println("Hello");
        Test1 t=new Test1();
        System.out.println("World");

    }

结果如下：

这是静态代码块
Hello
这是普通代码块
这是一个无参构造方法
World

输出结果证明了我们的想法，那就是：
找到main()方法 —> 初始化静态代码块 —> 回到main()方法 —>执行main()方法里面的程序，创建对象 —> 执行非静态代码和构造方法 —> 再回到main()方法执行下面的语句

为了说明类与静态代码是相关的，即类如果已经被加载了，再次加载类时，静态代码块也不会再次初始化。

修改main()方法如下：

    public static void main(String[] args) {
        Test1 t=new Test1();
        Test1 tt=new Test1();

    }

运行结果如下：

这是静态代码块
这是普通代码块
这是一个无参构造方法
这是普通代码块
这是一个无参构造方法

分析如下：
虽然连续创建了两次对象，但类在找到main()方法后已经被加载过了，静态代码块也就是在这个时候加载的，再次创建对象时，只执行跟对象有关的代码块，所以静态代码块跟类有关，只会跟类一起加载一次，而非静态代码快随着对象的创建而不断加载。

是不是感觉已经明白的差不多了，别着急，我们在看一个程序：

public class Test1 {
    static Test1 t1=new Test1();

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

    {
        System.out.println("这是普通代码块");
    }

    public static void method(){
        System.out.println("这是一个静态方法");
    }

    public void method2(){
        System.out.println("这是一个普通方法");
    }

    public Test1(){
        System.out.println("这是一个无参构造方法");
    }


    public static void main(String[] args) {

    }

}

运行结果如下：

这是普通代码块
这是一个无参构造方法
这是静态代码块

代码分析如下：
JVM在找到main()方法后，初始化类，去执行静态代码，而静态代码刚好是一个创建对象的过程，我们又知道非静态代码才是跟对象有关的，所以会再次进入这个类去寻找非静态代码块，所以我们看到的结果是先输出了普通代码块和构造方法，创建对象完成后，JVM继续初始化类，第一个静态代码已经执行完毕，接下类执行下一个静态代码块，也就是我们看到的输出了静态代码块。然后回到main()方法，main()方法里面没有内容，所以程序运行结束。

如果我们在main()里面创建一个对象会怎么样呢？

修改main()方法如下：

    public static void main(String[] args) {
        Test1 t=new Test1();    
    }

运行结果如下：

这是普通代码块
这是一个无参构造方法
这是静态代码块
这是普通代码块
这是一个无参构造方法

分析如下：
前三个输出结果如我们预料的一样，当回到main()方法时，创建对象，就执行非静态代码，那么就会输出后两行结果。

如果我们仔细观察会发现，static Test1 t1=new Test1()这行代码为什么不是死循环呢，因为new Test1()会进入Test1()类，但是只会执行非静态代码，也就是不会再执行new Test1()了，所以自然不会死循环。但是如果去掉static那么我们看一下结果：

这是静态代码块
Exception in thread "main" java.lang.StackOverflowError
at test.Test1.<init>
....
....

会报错，是因为无限制创建对象的结果，因为在执行完静态代码后，创建对象后会继续执行非静态代码，然后再创建对象，再执行非静态代码…如此循环下去，内存被耗完，所以就会报错。

再考虑一种情况，有两个类：

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

    {
        System.out.println("这是普通代码块");
    }

    public static void method(){
        System.out.println("这是一个静态方法");
    }

    public void method2(){
        System.out.println("这是一个普通方法");
    }

    public Test2(){
        System.out.println("这是一个无参构造方法");
    }


    public static void main(String[] args) {
        System.out.println("hhellp");
        Test1 t=new Test1();    
    }

}

   public class Test1{
       public static void main(String[] args) {
            Test2 t=new Test2();    
            Test2 tt=new Test2();
        }
   }

运行结果为：

这是静态代码块
这是普通代码块
这是一个无参构造方法
这是普通代码块
这是一个无参构造方法

代码分析：
JVM首先会加载main()方法所在的类，加载这个类的静态方法，发现没有后回到main()方法，执行这行代码 Test2 t=new Test2()，也就是创建Test2()的对象，所以JVM又要开始加载这个类，因为这个类之前没有被加载过，所以会先运行静态代码块来初始化类，然后再运行普通代码块然后使用构造方法，这也是前三行的结果，然后再次回到main()方法，执行这行代码 Test2 t=new Test2()，然后发现Test2()这个类已经被JVM加载过了，所以不需要初始化类，直接调用非静态方法就可以了。

其实，上面说了那么多，就一个道理而已：

静态代码是与类有关的，类加载一次，静态代码也就只会加载一次。非静态代码是与对象有关的，对象创建几次就执行几次。

加载顺序只是表象，而JVM的底层加载才是真理呀！