一文以概之：Java类成员加载顺序

于 2022-07-29 15:45:07 发布
阅读量517 收藏 2
点赞数 1
分类专栏： java 文章标签： java jvm
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wohuizuofan1/article/details/126053003
版权

Java类成员加载顺序

1. 导入

最近在阅读Thinking in Java，谈到Java类成员加载顺序一部分，不由想起以前被大学老师支配的恐惧，但是翻看此书之后，有点豁然开朗之感，遂起心思，想要写一篇文章，详细分析Java类成员加载顺序，希望能够帮助新人朋友们，如有失误之处，劳请指出，感激不尽。

2. 分析之前

在开始长篇大论之前，我想先写一点简单但需要注意的知识：

2.1 变量定义的顺序决定了初始化的顺序

咱先举一个🌰，我喜欢🐕，咱们先写一个阿拉斯加吧。

import java.util.*;

/**
 * @author LKQ
 * @date 2022/7/28 19:07
 * @description
 */
public class Alaska {
    private static int i = print("大白");
    private static int j = print("小黄");
    static int print(String s) {
        System.out.println(s);
        return 0;
    }
    public static void main(String[] args) {
       	
    }
}

Output:
大白
小黄

public class Alaska {
    private static int j = print("小黄");
    private static int i = print("大白");
    static int print(String s) {
        System.out.println(s);
        return 0;
    }
    public static void main(String[] args) {
       	
    }
}

Output:
小黄
大白

从上面可以看出，大白i和小黄j两个变量，定义的顺序不同，输出的结果顺序也不同。

请注意，虽然main()啥也没干，但是会有输出。

2.2 类中每个成员都有默认值

public class Alaska {
    private static boolean isSick;
    private static int age;
    private static String name;
    private static double weight;
    public static void main(String[] args) {
       	System.out.println("Data type: Initial Value");
        System.out.println("boolean: " + isSick);
        System.out.println("int: " + age);
        System.out.println("String: " + name);
        System.out.println("double: " + weight);
    }
}

Output:
Data type: Initial Value
boolean: false
int: 0
String: null
double: 0.0

可以看到，我们并没有给这个变量赋值，但依然有其对应的默认值。

2.3 静态初始化只执行一次，且在这个类最开始被使用的时候

public class Alaska {
    
    private static int i = 10;
    static {
        System.out.println("Alaska static block initialized");
    }
    static class AlaskaInner {
        AlaskaInner() {
            System.out.println("static class AlaskaInner initialized");
        }
        static {
            System.out.println("static class AlaskaInner static initialized");
        }
    }
    private static String name = getName();
    {
        System.out.println("Alaska non-static block initialized");
    }
    private static String getName() {
        System.out.println("alaska - 阿拉斯加");
        return "alaska";
    }
    Alaska() {
        System.out.println("Alaska constructor");
    }
    public static void main(String[] args) {
        System.out.println("create a new Alaska");
        Alaska a = new Alaska();
    }
}

Output:
Alaska static block initialized
alaska - 阿拉斯加
create a new Alaska
Alaska non-static block initialized
Alaska constructor

假设我们养两只阿拉，会发生什么呢？

public class Alaska {
    
    private static int i = 10;
    static {
        System.out.println("Alaska static block initialized");
    }
    static class AlaskaInner {
        AlaskaInner() {
            System.out.println("static class AlaskaInner initialized");
        }
        static {
            System.out.println("static class AlaskaInner static initialized");
        }
    }
    private static String name = getName();
    {
        System.out.println("Alaska non-static block initialized");
    }
    private static String getName() {
        System.out.println("alaska - 阿拉斯加");
        return "alaska";
    }
    Alaska() {
        System.out.println("Alaska constructor");
    }
    public static void main(String[] args) {
        System.out.println("create a new Alaska");
        Alaska a = new Alaska();
        Alaska a1 = new Alaska();
    }
}

Output:
Alaska static block initialized
alaska - 阿拉斯加
create a new Alaska
Alaska non-static block initialized
Alaska constructor
Alaska non-static block initialized
Alaska constructor

可以看到，静态的初始化，不管生成多少只阿拉，它只会执行一次。

而非静态初始化以及构造器，每 new Alaska()都执行了一次。

注意：静态内部类并没有初始化。只用在调用了静态内部类时，才会进行初始化。

    public static void main(String[] args) {
        System.out.println("create a new Alaska");
        Alaska a = new Alaska();
        Alaska a1 = new Alaska();
        AlaskaInner alaskaInner = new AlaskaInner();
    }

Output:
Alaska static block initialized
alaska - 阿拉斯加
create a new Dog
Alaska non-static block initialized
Alaska constructor
Alaska non-static block initialized
Alaska constructor
static class AlaskaInner static initialized
static class AlaskaInner initialized

如果一只不养但是看到别人养了呢？

public class Alaska {
    
    private static int i = 10;
    static {
        System.out.println("Alaska static block initialized");
    }
    static class AlaskaInner {
        AlaskaInner() {
            System.out.println("static class AlaskaInner initialized");
        }
        static {
            System.out.println("static class AlaskaInner static initialized");
        }
    }
    private static String name = getName();
    {
        System.out.println("Alaska non-static block initialized");
    }
    private static String getName() {
        System.out.println("alaska - 阿拉斯加");
        return "alaska";
    }
    Alaska() {
        System.out.println("Alaska constructor");
    }
}
class Dog {
    public static void main(String[] args) {
        System.out.println("create a new dog");
        Alaska.getName();
    }
}

Output:
create a new dog
Alaska static block initialized
alaska - 阿拉斯加
alaska - 阿拉斯加

如果不喜欢🐶，也没看到别人家的狗。

class Dog {
    public static void main(String[] args) {
        // Alaska a = new Alaska();
        // Alaska a1 = new Alaska();
        System.out.println("我不喜欢阿拉");
    }
}

Output:
我不喜欢阿拉

那么，是否可以得出这样的结论：静态初始化，只执行一次：当首次生成这个类的对象，或者首次访问属于那个类的静态数据成员时（即使从未生成过那个类的对象）。请好好琢磨

3. 步入正题

还是以上面的阿拉为例，现在我们清除不必要的东西，只保留部分内容，并进行适当的扩展。一步一步来分析。

import java.util.*;

/**
 * @author LKQ
 * @date 2022/7/28 19:07
 * @description
 */
public class Alaska extends Dog{
	static {
        System.out.println("Alaska static initialized");
    }
    public static void main(String[] args) {
        System.out.println("create a new Alaska");
    }
}
class Dog extends Animal{
	static {
        System.out.println("Dog static initialized");
    }
}
class Animal {
    static {
        System.out.println("Animal static initialized");
    }
}

Output:
Animal static initialized
Dog static initialized
Alaska static initialized
create a new Alaska

如果不让 Alaska extends Dog

Output:
Alaska static initialized
create a new Alaska

在Alaska运行Java时，所发生的第一件事情就是试图访问Alaska.main()(一个静态方法)。于是加载器开始启动，并找出Alaska类的编译代码（Alaska.class文件中）。加载过程中，编译器注意到它有一个基类Dog (由extends得知），于是它继续加载Dog，不管有没有产生一个该基类的对象，这都要发生。

如果该基类还有其自身的基类，那么第二个基类就会被加载，如此类推。 自底向上找到根基类后Animal，然后自顶向下执行static初始化。这其实就是Java类加载时的双亲委派模型机制。

完成类加载后，对象就可以被创建了。2.2说过，对象中的所有基本类型都被设为默认值，对象引用被设为null。这是通过将对象内存设为二进制零值而一举生成的。

那么实例变量和构造器谁先加载呢？

import java.util.*;

/**
 * @author LKQ
 * @date 2022/7/28 19:07
 * @description
 */
public class Alaska extends Dog{
    private static int i = 10;
    public int d = print();
    static {
        System.out.println("Alaska static initialized");
    }
    Alaska() {
        System.out.println("Alaska constructor");
    }
    public static void main(String[] args) {
        System.out.println("create a new Alaska");
        Alaska alaska = new Alaska();
    }
}
class Dog extends Animal{
    private static int j = 5;
    public int d = print();
    static {
        System.out.println("Dog static initialized");
    }
    Dog() {
        System.out.println("Dog constructor ");
    }
}
class Animal {
    private static int k = 0;
    private int a = print();
    static {
        System.out.println("Animal static initialized");
    }
    int print() {
        System.out.println("Animal instance variable initialized " + k + " time");
        k++;
        return k;
    }
    Animal() {
        System.out.println("Animal constructor");
    }
}

Animal static initialized
Dog static initialized
Alaska static initialized
create a new Alaska
Animal instance variable initialized 0 time
Animal constructor
Animal instance variable initialized 1 time
Dog constructor
Animal instance variable initialized 2 time
Alaska constructor

    // 如果这里修改为如下代码
	public static void main(String[] args) {
        System.out.println("create a new Dog");
        Dog dog = new Dog();
    }

Output:
Animal static initialized
Dog static initialized
Alaska static initialized
create a new Dog
Animal instance variable initialized 0 time
Animal constructor
Animal instance variable initialized 1 time
Dog constructor

可以看到，首先是static初始化，从父类到子类输出。然后new Alaska()时，根父类实例变量 a 先初始化，然后调用其构造器完成初始化，顺序也是从根父类到子类。

得出结论：实例变量 > 构造器

那加入非静态初始化块呢？它应该出现在哪？

import java.util.*;

/**
 * @author LKQ
 * @date 2022/7/28 19:07
 * @description
 */
public class Alaska extends Dog{
    private static int i = 10;
    public int d = print();

    static {
        System.out.println("Alaska static block initialized");
    }
    {
        System.out.println("Alaska non-static block initialized");
    }
    Alaska() {
        System.out.println("Alaska constructor");
    }
	
    public static void main(String[] args) {
        System.out.println("create a new Alaska");
        Alaska a = new Alaska();
    }
}
class Dog extends Animal{
    private static int j = 5;
    public int d = print();
    static {
        System.out.println("Dog static initialized");
    }
    {
        System.out.println("Dog non-static block initialized");
    }
    Dog() {
        System.out.println("Dog constructor ");
    }
}
class Animal {
    private static int k = 0;
    private int a = print();
    static {
        System.out.println("Animal static initialized");
    }
    {
        System.out.println("Animal non-static block initialized");
    }
    int print() {
        System.out.println("Animal instance variable initialized " + k + " time");
        k++;
        return k;
    }
    Animal() {
        System.out.println("Animal constructor");
    }
}

Output:
Animal static initialized
Dog static initialized
Alaska static block initialized
create a new Alaska
Animal instance variable initialized 0 time
Animal non-static block initialized
Animal constructor
Animal instance variable initialized 1 time
Dog non-static block initialized
Dog constructor
Animal instance variable initialized 2 time
Alaska non-static block initialized
Alaska constructor

可以看到，非静态初始块顺序 出现在 实例变量 和 构造器 之间。

得出结论：实例变量 > 非静态初始块 > 构造器

4. 总结

借鉴Thinking in Java来下个结论吧。假设有一个Dog类：

  1. 即使没有显示地使用static关键字，构造器实际上也是静态方法。因此，当首次创建类型为Dog的对象时（构造器可以看成静态方法），或者Dog类的静态方法/静态域首次被访问时，Java解释器必须查找类路径，以定位Dog.class文件。如果有基类存在，那么继续往上定位。
  2. 载入Dog.class，这将创建一个Class对象，有关静态初始化的所有动作都会执行。因此，静态初始化只在Class对象首次加载的时候进行一次。
  3. 当用 new Dog()创建对象时，首先在堆上为Dog对象分配足够的存储空间。
  4. 这块存储空间会被清零，这就自动地将Dog对象中的所有基本类型数据都设置成了默认值，而引用类型则被设置为null。
  5. 从根基类开始，每创建一个对象，依次初始化 实例变量、非静态初始块、构造器，然后到子类。
苏格拉没有底v
关注
  • 1
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
专栏目录
Java类加载器加载类顺序
12-22
java ClassLoader的学习 　　java是一门解释执行的语言，由开发人员编写好的java源文件先编译成字节码文件.class形式，然后由java虚拟机(JVM)解释执行，.class字节码文件本身是平台无关的，但是jvm却不是，为了实现所谓的一次编译，到处执行，sun提供了各个平台的JVM实现–也是说jvm不是跨平台的，编译好的字节码文件被放在不同的操作系统平台上的jvm所解释执行，这个章节主要解释一下JVM装载类的机制 　　1.ClassLoader是什么？ 　　一个类如果要被JVM所调度执行，必须先把这个类加载到JVM内存里，java.lang下有个很重要的类ClassL
Java类的加载顺序
weixin_30618985的博客
09-14 162
1、有继承关系的加载顺序 关于关键字static，大家 都知道它是静态的，相当于一个全局变量，也就是这个属性或者方法是可以通过类来访问，当class文件被加载进内存，开始初始化的时候，被static修饰的变量或者方法即被分配了内存，而其他变量是在对象被创建后，才被分配了内存的。 所以在类中，加载顺序为： 1.首先加载父类的静态字段或者静态语句块 2.子类的静态字段或静态语句块 3.父类普通变量以及...
java中类的加载顺序介绍(ClassLoader)
热门推荐
eff666的博客
08-14 6万+
1、ClassNotFoundExcetpion 我们在开发中，经常可以遇见java.lang.ClassNotFoundExcetpion这个异常，今天我就来总结一下这个问题。对于这个异常，它实质涉及到了java技术体系中的类加载。Java的类加载机制是技术体系中比较核心的部分，虽然它和我们直接打交道不多，但是对其背后的机理有一定理解有助于我们排查程序中出现的类加载失败等技术问题。
一文读懂Jvm类加载机制
08-25
主要介绍了一文读懂Jvm类加载机制,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
一文搞懂java的String类和Date类
12-21
文章目录String类概述String对象创建字符串拼接问题常用方法StringBuffer、StringBuilderDate类 你还在被String类的各种神仙问题困扰吗？ String的底层存储 String的存储区 String的相等判断 String的常用方法 不用...
一文带你吃透Java中的String类.rar
最新发布
07-10
一文带你吃透Java中的String类.rar
Java类加载与锁
12-22
本文写作的灵感来自Pierre-Hugues Charbonneau的为什么加载不存在的类会影响系统性能一文。这让我想起了之前的一次调试经历，当时也遇到了类似的问题，只不过表现略有不同。 　出问题的应用程序是Yet Another ...
一文深入了解：分布式系统中的缓存架构
02-24
缓存主要分为四类，如下图：CDN缓存CDN(ContentDeliveryNetwork内容分发网络)的基本原理是广泛采用各种缓存服务器，将这些缓存服务器分布到用户访问相对集中的地区或网络中。在用户访问网站时，利用全局负载技术将...
Java--类的加载顺序
NMZLduiduidui的博客
12-12 642
来源：https://www.cnblogs.com/sxkgeek/p/9647992.html 1、有继承关系的加载顺序 关于关键字static，大家 都知道它是静态的，相当于一个全局变量，也就是这个属性或者方法是可以通过类来访问，当class文件被加载进内存，开始初始化的时候，被static修饰的变量或者方法即被分配了内存，而其他变量是在对象被创建后，才被分配了内存的。 所以在类中，加...
java所有类加载顺序_Java类加载顺序
weixin_35241413的博客
02-26 105
问题：i和n到底是什么时候声明的，publicstaticTest1t1=newTest1("t1");这句会去执行构造块和构造方法,但是这时候publicstaticinti=print("i");并没执行，i是哪里出来的？它是按顺序先声明所有变量然后才从头再挨个赋值吗？关于这个问题:类的生命周期分为如下几个阶段,Loading,Linking,Initialization.Loa...
Java类成员加载顺序
我家有个小喵咪
04-28 297
这世界上没有优秀的理念，只有脚踏实地的结果 。 大家面试的时候有没有被问到过当我们初始化一个类的时候，类的成员加载顺序是什么？ 接下来我们通过一段代码来看一下： package com.demo_maven.demo_maven.VolatileDemo; public class ClassLoadDemo { public static void main(String[] args) { Son son = new Son(); } } class..
Java类加载顺序
weixin_44120790的博客
08-13 250
先导知识： 类加载时，从上往下先执行静态初始化语句，初始化块 创建类对象时，从上到下先执行非静态初始化语句，初始化块，最后执行构造方法； 静态的资源属于类所有，在类加载时就要分配内存空间。而非静态资源属于对象所有，只有在实例化时才会分配内存空间； 先类加载后创建对象 在类加载过程中遇到对象创建，则按照对象创建执行顺序。 初级： 已经标注执行顺序： 类加载–静态变量、静态方法–>创建类对象–非静态变量 / 非静态代码块 - - - > 构造器 public class Strings {
Java类加载的顺序
qq_35387404的博客
08-12 156
Java类加载的顺序 类加载优于类实例化对象 类加载：程序从上到下，加载静态的初始化语句，初始化块和构造方法 类创建对象：程序从上到下，加载非静态的初始化语句，初始化块和构造方法 类初始化变量初始值 类初始化变量的默认值如下： byte、short、int ：0 long ：0L float ：0.0f double ：0.0d char ：空字符（即：/u0000） boolean ：false 引用类型 ：null 代码示例 public cla
Java类中成员加载顺序
老头儿ii的博客
08-31 521
一直对类中成员的加载过程很迷糊，所以打算测试一下，如果有不正确的地方希望大佬指出 代码 public class Main { private int generalMember = staticMember + 100;//普通成员 private static int staticMember = 10;//静态成员 static { System....
关于java中类成员的加载顺序
qq_58022841的博客
04-07 1443
这是关于java类中成员的加载顺序
Java类中的各种成员的加载顺序
创创创创。创健 的博客
04-22 207
（复制自 我自己的 有道笔记） 静态成员加载顺序（从上至下）： 加载Super的静态变量 加载Super的静态块 加载Sub的静态变量 加载Sub的静态块 非静态加载顺序（从上至下）： 加载Super的实例变量 加载Super的普通块 加载Super的构造器 加载Sub的实例变量 加载Sub的普通块 加载Sub的构造器 可...
java long范围_一文详解 Java 的八大基本类型！
05-20
Java 的八大基本类型包括： 1. byte（字节型）：8 位，有符号的整数类型，取值范围为 -128 到 127。 2. short（短整型）：16 位，有符号的整数类型，取值范围为 -32768 到 32767。 3. int（整型）：32 位，有符号的...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值