Java class 初始化和实例化练习

原创 已于 2022-04-12 00:29:48 修改 · 3k 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#java #jvm

于 2022-04-12 00:28:22 首次发布
这篇博客详细探讨了Java类的初始化时机，包括从JVM和Java文档的角度出发的初始化条件。还讨论了循环依赖的解决方案，并阐述了实例初始化的步骤，强调了不要在父类构造器中调用子类方法。此外，提供了实例初始化的练习题来加深理解，最后讲解了final变量的编译阶段特性。

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

类初始化

初始化时机:

初始化是执行 class 或 interface 的初始化方法 <init>, 以下内容来自 JVM 文档 1 :

  • 当执行这些虚拟机指令时: new T, 存取 T 的静态变量/方法
  • new, 静态资源相关的 MethodHandle 实例被调用
  • 一些反射方法被调用. 例如 Class 的方法
  • T(T 是 class) 的子类被初始化
  • T(T 是 interface) 的实现类被初始化
  • T 是JVM启动时的初始化类

以下内容来自 Java 文档 2 :

  • T is a class and an instance of T is created.
  • A static method declared by T is invoked.
  • A static field declared by T is assigned.
  • A static field declared by T is used and the field is not a constant variable (§4.12.4).
  • T is a top level class (§7.6) and an assert statement (§14.10) lexically nested within T (§8.1.3) is executed.

循环依赖:

package com.lvw.jvm.init_class;

public class CircleInitializing {

    public static void main(String[] args) {
        int f = Sub.f;
    }

    static class Super {
        static int f = 1;   // 1
        static {  // 2
            System.out.println("Super is initializing.");
            Sub.run();  // 3
            System.out.println("Super was initialized.");
        }
        static void run() {
            System.out.println("Super.run() was called.");
        }
    }

    static class Sub extends Super { // 4 recursive init for Super
        static {
            System.out.println("Sub is initializing.");
            Super.run();
            System.out.println("Sub was initialized.");
        }
        static void run() {
            System.out.println("Sub.run() was called.");
        }
    }
}

/*
output:
Super is initializing.
Sub is initializing.
Super.run() was called.
Sub was initialized.
Sub.run() was called.
Super was initialized.
*/

循环依赖的解决方法:

首先, 在 C 的 Class 对象中保存一个状态, 这个状态有四个取值:

  • C 已经验证ok且准备好了, 但未被初始化
  • C 正在被初始化
  • C 已经初始化完成
  • C 初始化失败

其次, 维护一个 Lock, 用来串行化初始化.

对于一个初始化线程, 具体初始步骤为:

  1. 获取 Lock
  2. 如果 C 正在被其他线程初始化, 则 block 自己
  3. #todo

关于循环依赖的原文看这里

碎片补充:

  • 涉及某个类不一定会初始化, 只有静态资源被访问才会导致静态资源所在的类被初始化. 举一个例子: 如果 A 继承 B { static int f = 1;}, 对 A.f 的访问会导致 B 的初始化, 但不会初始化 A.
  • 初始化中的循环依赖的解决方法: 在 Class 对象中
  • static final a = 1; 是编译期常量, 对这种常量的访问不会导致初始化.
  • static final a = random(); 这是运行期常量, 这会导致初始化.

实例初始化

步骤:

  • 递归初始化父类
  • 初始化
    • 初始化 Class
      • 类变量赋值(static) 只执行一次
      • 静态初始化块(static {}) 只执行一次
    • 初始化实例
      • 实例变量赋值(非static) 每个对象执行一次
      • 实例变量初始化块({}) 每个对象执行一次
      • 构造函数 每个对象执行一次

不要在父类的构造方法中调用子类的方法.

实例初始化的练习

设 C 为当前正在实例化的类型. C初始值 = T

1 找到 C 的 Class object

2.a 如果有父类或接口, 先初始化父类和接口 (回到0)

2.b 如果没有父类和接口, 继续 3

3.a 如果还未初始化, 则先初始化

从上到下, 初始化类变量, 执行静态初始化块, 如果遇到 new 或者 静态资源引用了其他类 D, C = D, 回到 1. 否则继续 4.

3.b 如果正在初始化或已经完成初始化, 则继续 4

通过 Class 的状态可以判断出是否正在初始化, 如果是在初始化中, 说明发生了递归, 此时无需再次执行初始化逻辑.

4 为实例变量赋值

遇到 new 回到 0.

5 执行构造函数

如果是在初始化中, 静态变量可能是初始值或者null.

练习1

package com.lvw.jvm.init_class;

class CA {
    private static String ivar = null;
    static CB other = new CB("CA.other of static");
    static {
        System.out.println("in CA init");
        ivar = new String("2");
    }
    CA(String caller) {
        System.out.println("CA.CONSTRUCTOR by " + caller + ", ivar:" + ivar);
    }
}
class CB {
    public int ivar = 2;
    static {
        System.out.println("in CB init");
    }
    static CA other1 = new CA("CB.other1");
    CA other2 = new CA("CB.other2");
    CB(String caller) {
        System.out.println("CB.CONSTRUCTOR by " + caller);
    }

    public static void main(String[] args) {
        CB cb = new CB("main");
    }
}

开始分析, 先写出第一层

CB cb = new CB("main");
	static{ System.out.println("in CB init"); } // 静态初始化块 步骤 3.a
	static CA other1 = new CA("CB.other1");     // 类变量 步骤 3.a
	CA other2 = new CA("CB.other2");            // 实例变量 步骤 4
	CB <CONSTRUCTOR>  System.out.println("CB.CONSTRUCTOR by " + caller); // 构造方法 步骤 5

然后补充第二层, 第三层…, 每缩进一层相当于回到步骤1

CB cb = new CB("main");
	static{ System.out.println("in CB init"); } // 静态初始化块 3.a
	static CA other1 = new CA("CB.other1");     // 类变量 3.a
		static String ivar = null;  // 类变量 3.a
		static CB other = new CB("CA.other of static");  // 初始化 3.a
			CA other2 = new CA("CB.other2");  // 实例变量 3.b
				CA <CONSTRUCTOR> System.out.println("CA.CONSTRUCTOR by " + caller + ", ivar:" + ivar);
			CB <CONSTRUCTOR>  System.out.println("CB.CONSTRUCTOR by " + caller);
		static {System.out.println("in CA init"); ivar = new String("2");}  // 静态初始化块 3.a
		CA <CONSTRUCTOR> System.out.println("CA.CONSTRUCTOR by " + caller + ", ivar:" + ivar); // 构造方法 5
	CA other2 = new CA("CB.other2");            // 实例变量 4
		CA <CONSTRUCTOR> System.out.println("CA.CONSTRUCTOR by " + caller + ", ivar:" + ivar);
	CB <CONSTRUCTOR>  System.out.println("CB.CONSTRUCTOR by " + caller); // 构造方法 5

分析结果: 即把所有 System.out.println 按顺序写出来:

in CB init
CA.CONSTRUCTOR by CB.other2, ivar: null
CB.CONSTRUCTOR by CA.other of static
in CA init
CA.CONSTRUCTOR by CB.other1, ivar: 2
CA.CONSTRUCTOR by CB.other2, ivar: 2
CB.CONSTRUCTOR by main

注意上面的 ivar 变量第一次被引用的时候, 还未被初始化.

练习2

package com.lvw.jvm.init_class;

class CA {
    private static String ivar = null;
    static CB other = new CB("CA.other of static");
    static {
        System.out.println("in CA init");
        ivar = new String("2");
    }
    CA(String caller) {
        System.out.println("CA.CONSTRUCTOR by " + caller + ", ivar:" + ivar);
    }
}
class CB {
    public int ivar = 2;
    static {
        System.out.println("in CB init");
    }
    CA other1 = new CA("CB.other1"); // 去掉了 static
    CA other2 = new CA("CB.other2");
    CB(String caller) {
        System.out.println("CB.CONSTRUCTOR by " + caller);
    }

    public static void main(String[] args) {
        CB cb = new CB("main");
        // CA ca = new CA("main");
    }
}

分析过程:

CB cb = new CB("main");
	static{ System.out.println("in CB init"); } 
    CA other1 = new CA("CB.other1");
		static String ivar = null;
		static CB other = new CB("CA.other of static");
			CA other1 = new CA("CB.other1");
				CA <CONSTRUCTOR> System.out.println("CA.CONSTRUCTOR by " + caller + ", ivar:" + ivar);
			CA other2 = new CA("CB.other2");
				CA <CONSTRUCTOR> System.out.println("CA.CONSTRUCTOR by " + caller + ", ivar:" + ivar);
			CB <CONSTRUCTOR>  System.out.println("CB.CONSTRUCTOR by " + caller);
		static {System.out.println("in CA init"); ivar = new String("2");}
		CA <CONSTRUCTOR> System.out.println("CA.CONSTRUCTOR by " + caller + ", ivar:" + ivar);
    CA other2 = new CA("CB.other2");
		CA <CONSTRUCTOR> System.out.println("CA.CONSTRUCTOR by " + caller + ", ivar:" + ivar);
	CB <CONSTRUCTOR>  System.out.println("CB.CONSTRUCTOR by " + caller);

分析结果:

in CB init
CA.CONSTRUCTOR by CB.other1, ivar: null
CA.CONSTRUCTOR by CB.other2, ivar: null
CB.CONSTRUCTOR by CA.other of static
in CA init
CA.CONSTRUCTOR by CB.other1, ivar: 2
CA.CONSTRUCTOR by CB.other2, ivar: 2
CB.CONSTRUCTOR by main

final 变量

final在编译阶段完成, 如果修改final类型的常量后不要增量部署, 因为所以使用了这个变量的地方不会修改. (https://blog.youkuaiyun.com/momo_ibeike/article/details/80257552)

appendix

  • dynamic call site : 指的是一次动态调用
  • Call site specifier : 是一个 item, 解释如何链接到给定的 call site

  1. https://docs.oracle.com/javase/specs/jvms/se8/html/jvms-5.html#jvms-5.5 ↩︎

  2. https://docs.oracle.com/javase/specs/jls/se8/html/jls-12.html#jls-12.4.1 ↩︎

java 类的初始化
11-14 159
Java类的初始化 我们知道一个类(class)要被使用必须经过装载，连接，初始化这样的过程。下面先对这三阶段做一个简单的描述，之后会结合一个简单的例子来说明java中类的初始化过程。 在装载阶段，类装载器(Bootstrap ClassLoader 或者用户自定义的ClassLoader) 把编译形成的class文件载入内存，创建类相关的Class对象，这个Class对象封装...
java class的方法_实例化Class的方法(三种)
weixin_39843078的博客
02-12 270
该楼层疑似违规已被系统折叠隐藏此楼查看此楼package reflect;//获取Class方式一：通过java虚拟机提供的输出Xxx.class获取public class GetClassDemo1 {public static void main(String[] args) {Class clazz = Person.class;// 每个类都有的属性，是java虚拟机给的System....
类初始化阶段详解
最新发布
m0_75107803的博客
06-02 616
初始化时机：严格遵循JVM规范的6种主动引用场景<clinit>方法：编译器自动生成，合并所有静态操作执行顺序：父类优先，按代码顺序执行线程安全：JVM内部锁确保单线程执行初始化失败：导致优化实践：合理使用延迟加载和final常量理解类初始化机制是掌握Java类加载过程的关键，它直接影响程序的性能、稳定性和设计模式实现。通过合理控制初始化时机和内容，可以构建更高效、更健壮的Java应用程序。
Java类的初始化
aoe41606的博客
03-23 840
Java类的初始化 我们知道一个类(class)要被使用必须经过装载，连接。初始化这种过程。以下先对这三阶段做一个简单的描写叙述。之后会结合一个简单的样例来说明java中类的初始化过程。 在装载阶段，类装载器(Bootstrap ClassLoader 或者...
Java Class 初始化
weixin_34189116的博客
09-09 390
为什么80%的码农都做不了架构师？>>> ...
Java 类的初始化
suming97的博客
07-12 3992
Java类加载的详细过程与相关规则
“礼让”原则学习Java对象初始化顺序.pdf
12-27
"Java 对象初始化顺序学习指南" 在学习 Java 编程语言时，对象初始化顺序是一个非常重要的知识点，但是许多学生却感到困惑和困难。...只有通过实践和练习，学生才能真正地掌握 Java 对象初始化顺序的知识点。
java期末练习题和答案.doc
01-07
Java Programming Fundamentals Java 是一种广泛使用的编程语言，它广泛应用于 Android 应用程序开发、Web...知识点：静态初始化块是用于初始化静态变量的代码块，静态初始化块可以多次出现，并且可以在类中出现多次。
Java面向对象基础练习题
08-06
通过对上述练习题的分析，我们可以加深对Java面向对象编程中类和对象、实例变量、方法重载、构造方法、引用和this关键字的理解和应用。这些知识点对于日后进一步学习面向对象的高级特性，比如继承和多态，打下了坚实...
Java SE 全部学习练习代码和小的应用程序
04-12
在练习代码中，你可以看到如何定义类，如何通过构造函数初始化对象，以及如何使用继承来实现代码的复用。 3. **异常处理**：Java中的异常处理机制有助于编写健壮的代码。try-catch-finally结构用于捕获并处理运行时...
Java面试必备：类初始化顺序深度解析
"JAVA面试题解惑系列，深入解析Java基础概念，特别是类的初始化顺序，对于面试有极大帮助" 在Java编程语言中，类的初始化顺序是一个关键的知识点，对于理解和解决面试中的问题至关重要。当创建一个对象时，Java会...
java初始化属性 (转)
01-09 213
转自：http://www.cnblogs.com/miniwiki/archive/2011/03/25/1995615.html   1  无继承情况下的Java初始化顺序： class Sample {       Sample(String s)       {             System.out.println(s);       }       Sa...
【JAVA笔记——道】Class初始化理解
Contributor -> Committer
12-20 2163
静态域、非静态域、Final、父类以及抽象类正常实例化设置Initalized用于初始化时对于结果进行输出//被实例化类，设置初始方法用于显示初始化标记 public class Initalized { public Initalized(String s) { System.out.println(s); } }设置接口类用于测试类继承，设置内容如下interfa
java class练习
genuineZ2的博客
03-22 231
package z2; class Student{ protected String name; protected int age; public String getName() { return name; } public void setName(String stuName) { name=stuName; } public int getAge() { return age; } public void set
Java 类初始化
暮同学的博客
10-10 271
类初始化 类初始化是类加载过程的最后一个阶段，到初始化阶段，才真正开始执行类中的 Java 程序代码。虚拟机规范严格规定了有且只有四种情况必须立即对类进行初始化 遇到 new、getstatic、putstatic、invokestatic 这四条字节码指令时，如果类还没有进行过初始化，则需要先触发其初始化。生成这四条指令最常见的 Java 代码场景是：使用 new 关键字实例化对象时、读取或设置一个类的静态字段（static）时（被 static 修饰又被 final 修饰的，已在编译期把结果放入常量池
class的初始化
天生蠢才
05-19 1717
Normal07.8 磅02falsefalsefalseMicrosoftInternetExplorer4<!-- /* Font Definitions */ @font-face {font-family:宋体; panose-1:
JAVA 类的初始化
dingzepeng97的博客
07-05 270
类的初始化 之前的一篇文章是讲述的对象的初始化，这篇文章讲一讲类的初始化，以及类的初始化和对象初始化之间的一些异同。 首先同对象初始化一样，要搞清楚什么时候会进行类的初始化，和对象初始化不同，对象初始化的时候是new创建一个对象的时候，java会为对象进行初始化；而类的初始化进行的时机是：类第一次被使用的时候进行初始化，而且类的初始化只进行一次。 类被使用有三个情况：（1）、new 类名()
java类的练习
weixin_30530939的博客
08-29 247
结构 Cat.java package java_class_homework; public class Cat { String name; String type; String master; int age; // age public void setAge(int age) { this.age=age...
Java 类初始化（详解）
热门推荐
acherie的博客
02-22 2万+
JVM 如何进行类的初始化，实例的初始化，构造器的作用与调用。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值