类的主动使用实战

最新推荐文章于 2023-06-29 09:41:47 发布
最新推荐文章于 2023-06-29 09:41:47 发布
阅读量117 收藏
点赞数
分类专栏： JVM 文章标签： JVM
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/chengqiuming/article/details/119715344
版权

一 实战——实例化

1 代码

package chapter03.java1;

import org.junit.Test;

import java.io.*;

/**
* 测试类的主动使用：意味着会调用类的 <clinit>()，即执行了类的初始化阶段
*
* 当创建一个类的实例时，比如使用 new 关键字，或者通过反射、克隆、反序列化。
*/
public class ActiveUse1 {
    public static void main(String[] args) {
        // 使用 new 关键字
        Order order = new Order();
    }

    // 序列化的过程：
    @Test
    public void test1() {
        ObjectOutputStream oos = null;
        try {
            oos = new ObjectOutputStream(new FileOutputStream("order.dat"));


            oos.writeObject(new Order());
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                if (oos != null)
                    oos.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

    // 反序列化的过程：（验证）
    @Test
    public void test2() {
        ObjectInputStream ois = null;
        try {
            ois = new ObjectInputStream(new FileInputStream("order.dat"));
            Order order = (Order) ois.readObject();
        } catch (IOException e) {
            e.printStackTrace();
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        } finally {
            try {
                if (ois != null)
                    ois.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

class Order implements Serializable {
    static {
        System.out.println("Order类的初始化过程");
    }
}

2 测试

执行 main 方法时

Order类的初始化过程

执行 test1 时

Order类的初始化过程

执行 test2 时

Order类的初始化过程

二 实战——静态方法

1 代码

package chapter03.java1;

import org.junit.Test;

import java.io.*;

/**
* 测试类的主动使用：意味着会调用类的 <clinit>()，即执行了类的初始化阶段
*
* 当调用类的静态方法时，即当使用了字节码 invokestatic 指令。
*/
public class ActiveUse1 {
    @Test
    public void test3() {
        Order.method();
    }
}


class Order implements Serializable {
    static {
        System.out.println("Order类的初始化过程");
    }

    public static void method() {
        System.out.println("Order method()....");
    }
}

2 测试

Order类的初始化过程

Order method()....

三 实战——静态字段

1 代码

package chapter03.java1;

import org.junit.Test;

import java.util.Random;

/**
*
* 当使用类、接口的静态字段时(final修饰特殊考虑)，比如，使用 getstatic 或者 putstatic 指令。（对应访问变量、赋值变量操作）
*
*/
public class ActiveUse2 {
    @Test
    public void test1(){
        //System.out.println(User.num); // test1_1:类初始化了,因为 num 是变量
        //System.out.println(User.num1); // test1_2:类没有初始化，因为 num1 是静态常量
        System.out.println(User.num2); // test1_3:类初始化了，因为 num2 不是字面量方式声明的，需要方法调用，编译期间无法确定
    }

    @Test
    public void test2(){
        //System.out.println(CompareA.NUM1); // test2_1:接口不需要初始化，因为 NUM1 是静态常量
        //System.out.println(CompareA.NUM2); // test1_2:接口需要初始化。因为 因为 NUM2 不是字面量方式声明的，而是方法调用，编译期间无法确定
    }
}

class User{
    static{
        System.out.println("User类的初始化过程");
    }

    public static int num = 1;
    public static final int num1 = 1;
    public static final int num2 = new Random().nextInt(10);


}

interface CompareA{
    public static final Thread t = new Thread(){
        {
            System.out.println("CompareA的初始化");
        }
    };

    public static final int NUM1 = 1;
    public static final int NUM2 = new Random().nextInt(10);
}

2 测试

当只运行test1_1

User类的初始化过程

1

当只运行test1_2

1

当只运行test1_3

User类的初始化过程

8

当只运行test2_1

1

当只运行test2_2

CompareA的初始化

2

四 实战——类的主动使用其它情况

1 代码

package chapter03.java1;

import org.junit.Test;

import java.util.Random;

/**
* 类的主动使用其他情况
* 8. 当初次调用 MethodHandle 实例时，初始化该 MethodHandle 指向的方法所在的类。
* （涉及解析REF_getStatic、REF_putStatic、REF_invokeStatic方法句柄对应的类）
*/
public class ActiveUse3 {
    static {
        System.out.println("ActiveUse3的初始化过程");
    }

    // 4 当使用java.lang.reflect包中的方法反射类的方法时。比如：Class.forName("com.xxxx.xxx.Test")
    @Test
    public void test1() {
        try {
            Class clazz = Class.forName("chapter03.java1.Order");
            // 输出语句
            // ActiveUse3的初始化过程
            // Order类的初始化过程
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
    }

    // 5 当初始化子类时，如果发现其父类还没有进行过初始化，则需要先触发其父类的初始化。
    // 注意：
    // 当 Java 虚拟机初始化一个类时，要求它的所有父类都已经被初始化，但是这条规则并不适用于接口。
    // >在初始化一个类时，并不会先初始化它所实现的接口
    // >在初始化一个接口时，并不会先初始化它的父接口
    // 因此，一个父接口并不会因为它的子接口或者实现类的初始化而初始化。只有当程序首次使用特定接口的静态字段时，
    // 才会导致该接口的初始化。
    @Test
    public void test2() {
        System.out.println(Son.num);// 接口 CompareD 不会初始化
        // 依次输出
        // ActiveUse3的初始化过程
        // Father类的初始化过程
        // Son类的初始化过程
        // 1
    }

    @Test
    public void test3() {
        System.out.println(CompareC.NUM1); // CompareC 父接口 CompareB 并不会初始化
        // 依次输出
        // ActiveUse3的初始化过程
        // CompareC的初始化  --> 子接口初始化了，但是父接口并没有初始化
        // 2094196067
    }

    // 6 如果一个接口定义了 default 方法，那么直接实现或者间接实现该接口的类的初始化，该接口要在其之前被初始化。
    // 如果 Son2 还有子类，根据5,那么其子类的父类，父类的父类也都要被初始化
    @Test
    public void test4() {
        System.out.println(Son2.num);
        // 依次输出
        // ActiveUse3的初始化过程
        // Father类的初始化过程
        // CompareB的初始化 -> CompareB接口定义了default方法，所以接口要初始化，注意区分与CompareD的区别
        // Son2类的初始化过程
        // 1
    }

    // 7 当虚拟机启动时，用户需要指定一个要执行的主类（包含main()方法的那个类），虚拟机会先初始化这个主类。
    public static void main(String[] args) {
        System.out.println("hello");
        // 依次输出
        // ActiveUse3的初始化过程
        // hello
    }
}

class Father {
    static {
        System.out.println("Father类的初始化过程");
    }
}

class Son extends Father implements CompareD {
    static {
        System.out.println("Son类的初始化过程");
    }


    public static int num = 1;
}

class Son2 extends Father implements CompareB {
    static {
        System.out.println("Son2类的初始化过程");
    }


    public static int num = 1;
}

interface CompareB {
    public static final Thread t = new Thread() {
        {
            System.out.println("CompareB的初始化");
        }
    };

    public default void method1() {
        System.out.println("你好！");
    }
}

interface CompareC extends CompareB {
    public static final Thread t = new Thread() {
        {
            System.out.println("CompareC的初始化");
        }
    };

    public static final int NUM1 = new Random().nextInt();
}

interface CompareD {
    public static final Thread t = new Thread() {
        {
            System.out.println("CompareD的初始化");
        }
    };
}

2 测试

当执行 test1 时

ActiveUse3的初始化过程

Order类的初始化过程

当执行 test2 时

ActiveUse3的初始化过程

Father类的初始化过程

Son类的初始化过程

1

当执行 test3 时

ActiveUse3的初始化过程

CompareC的初始化

96077485

当执行 test4 时

ActiveUse3的初始化过程

Father类的初始化过程

CompareB的初始化

Son2类的初始化过程

1

当执行 main 时

ActiveUse3的初始化过程

hello

chengqiuming
关注
专栏目录
使用Windbg调试目标程序去分析异常的两实战案例分享
dvlinker的技术专栏
02-22 2万+
使用Windbg动态调试目标程序去分析异常的两实战案例分享。
13 使用Vue + FormData + axios实现图片上传功能实战
热门推荐
xingyu_qie的专栏
06-21 1万+
文本通过Vue实例项目，使用axios + FormData实现图片上传做为例子，为下一节图书信息上传做准备
深入理解JVM（12）——类加载（2）——类的主动使用和被动使用
波波鱼的博客
09-14 675
目录 1.Java对类的主动使用和被动使用 1.1 主动使用（七种） （1）上述主动使用规则的典型举例 （2）主动使用与final （3）初始化时类与接口的区别 1.2 被动使用 2.Java虚拟机与程序的生命周期 3.数组创建本质分析 4.类加载的准备阶段和初始化阶段的重要意义 1.Java对类的主动使用和被动使用 所有Java虚拟机实现必须在每个类或接口被Java程序“首...
类的主动使用
实践求真知
08-15 249
一 点睛 类在主动使用时，初始化方法会被调用。类在被动使用时，初始化方法不会被调用。 Class 只有在必须要首次使用的时候才会被装载，Java 虚拟机不会无条件地装载 Class 类型。Java 虚拟机规定，一个类或接口在初次使用前，必须要进行初始化。这里指的“使用”，是指主动使用，主动使用只有下列几种情况：（即：如果出现如下的情况，则会对类进行初始化操作。而初始化操作之前的加载、验证、准备已经完成。） 二 实例化 当创建一个类的实例时，比如使用 new 关键字，或者通过反射、克隆、反序列化。 .
类的主动使用和被动使用
CCC的博客
09-08 1109
JVM规范了以下6种主动使用类的场景： 1.通过new关键字会导致类的初始化：这种是大家经常采用的初始化一个类的方式，它肯定会导致类的加载并且最终初始化。 2.访问类的静态变量，包括读取和更新会导致类的初始化，这种情况的示例代码如下 public class Simple{ static{ System.out.println("I will be initiali...
类的主动使用与被动使用
weixin_30363509的博客
06-29 124
1.类的主动使用与被动使用 以下是视为主动使用一个类，其他情况均视为被动使用！ 1）：初学者最为常用的new一个类的实例对象（声明不会主动使用） 2）：对类的静态变量进行读取、赋值操作的。而对于静态常量（static final）不会初始化此类。 3）：直接调用类的静态方法。 4）：加载一个类或者反射调用一个类的方法。 5）：初始化一个类的子类的时候，父类也相当于...
类的主动使用：各种情况代码测试及理解
枫陵的博客
04-15 515
类的主动使用： Java程序对类的主动使用，意味着会调用类的<clinit>(),即执行类的初始化阶段。情况如下： 1. 创建类的实例时，比如使用new关键字，或通过反射、克隆、反序列化； 2. 调用某个类的静态方法时，即使用了字节码invokestatic指令； 3. 调用类或接口的静态字段时（final修饰符特殊考虑）； 4. 使用java.lang.reflec包中的方法反射类的方法：比如：Class.forName("com.hahaha.Test") 5. 初始化一个类的子
高效进行分类信息推广的一些实战技巧.docx
12-31
与传统广告不同，分类信息由用户主动搜索，因此更具吸引力和实用性。 **二、明确推广目标** 1. 直接带来客户，促进产品销售。 2. 提升企业品牌知名度。 3. 扩大信息覆盖面，辅助SEM（搜索引擎营销）。 4. 为网站...
HarmonyOS教育类APP项目实战系列课(1-10)
牛肉胡辣汤
06-29 807
Attributes & Styles：属性样式栏Grid：不能用于设置网格布局的______，该图标只有Div组件的Display样式被设置为grid时才会出现。Attributes & Styles：属性样式栏Properties：用于设置组件基本标识和外观显示特征的属性，如组件的______等属性。B. 不支持分布式但支持多端调测C. 不支持分布式但支单持多端调测D. 支持分布式但不支持多端调测。B. 不支持多端模拟仿真C. 不支持模拟仿真D. 支持单端模模拟仿真。A. 编码格式B. 版本信息。
学习《Netty实战》过程中使用到的案例.zip
最新发布
02-02
1. **ByteBuf**: Netty提供了自己的缓冲区类`ByteBuf`，它比Java NIO中的`ByteBuffer`更强大且易用。`ByteBuf`支持读写索引管理，可以避免不必要的内存复制，提高性能。在案例中，你会看到如何分配、读写和释放`...
Java类的主动使用（6种方式）
BigBunny
11-10 1332
▶创建类的实例 ▶访问某个类或接口的静态变量，或者对该静态变量赋值 ▶调用类的静态方法 ▶反射（如Class.forName("com.bunny.Test")） ▶初始化一个类的子类 ▶Java虚拟机启动时被表明为启动类的类（JavaTest）
Java之类的主动使用和被动使用
阿毅
05-24 1365
开心一笑「把你最值钱的东西交出来!」面对劫匪的恐吓，男友二话不说，把我给推了出去。一时间我竟不知应该感动还是生气。提出问题Java类的主动使用和被动使用分别是那些情况？？？解决问题Java类主动使用情况，会导致类的初始化： 1）创建类的实例 2）访问某个类或接口的静态变量，或者对该静态变量赋值 3）调用类的静态方法 4）反射（如Class.forName(“com.bunny.Test”)）
JVM总结二_类的主动使用
他山之石，可以凿玉
12-04 135
package com.ald.ups; /** * @describe: JVM learning * author: liutengyuan * @date: Created in 2017/12/4 14:22 **/ public class MyTest7 { /** * JVM 规范当设计到类的主动使用时，才去初始化类,由于各个虚拟机的厂商不同，JVM规范...
JVM - ClassLoader的双亲委派机制（沙箱安全机制）
后端学习
01-27 266
双亲委派机制 Java虚拟机对class文件采用的是按需加载的方式，也就是说当需要使用该类时才会将它的class文件加载到内存生成class对象。而且加载某个类的class文件时，Java虚拟机采用的是双亲委派模式，即把请求交由父类处理，它是一种任务委派模式。 工作原理 如果一个类加载器收到了类加载请求，它并不会自己先去加载，而是把这个请求委托给父类的加载器去执行； 如果父类加载器还存在其父类加载器，则进一步向上委托，依次递归，请求最终将到达顶层的启动类加载器； 如果父类加载器可以完成类加载任务，就成功返
Java中类的主动使用举例
Geek_ymv的专栏
08-07 298
Java中类的主动使用举例 在上一节中，我们知道Java程序对类对使用方式有两种：主动使用和被动使用。 其中Java程序对类的主动使用有5种情况，其余情况均为被动使用。 下面我们通过一个例子来看看主动使用： public class Test01ClassInit { public static void main(String[] args) { System.out....
深度剖析类加载器系列文章：二、类的主动使用和被动使用
nameisbill的博客
01-19 528
深度剖析类加载器系类文章：二、类的主动使用和被动使用 本文为本人理解总结，如有错误请指正 1.Java类的使用方式 Java程序对类的使用方式可以分为两种： 主动使用：会执行加载、连接、初始化 被动使用：只执行加载、连接，不执行类的初始化。 所有的Java虚拟机实现必须在类或接口被Java程序“首次主动使用”时才初始化它们（JVM规范）。 2.主动使用（六种） 创建类的实例 访问某个类或接口的
Java 类的主动使用和被动使用
zhouguizhi
06-29 572
Java程序对类的使用方式分为：主动使用和被动使用 主动使用，又分为七种情况: 1:创建类的实例 2:访问某个类或者接口的静态变量,或者对该静态变量赋值 3:反射( 比如:Class.forName(“java.lang.String))) 4:初始化一个类的子类 5:java虚拟机启动时被标明为启动类的类 6:java 7开始提供的动态语言支持 除了以上七种情况,其他使用Java类的方式都被看作是对类的被动使用都不会导致类的初始化 ...
JVM（4）：类的主动使用与被动使用、运行时数据区域内部结构、JVM线程说明、PC寄存器
游王子的博客
10-09 235
一、类的主动使用与被动使用 在JVM中表示两个class对象是否为同一个类存在两个必要条件： 类的完整类名必须一致，包括包名。 加载这个类的classLoader(指classLoader实例对象)必须相同。 换句话说，在JVM中，即使这两个类对象(class对象)来源同一个class文件，被同一个虚拟机所加载，但只要加载它们的ClassLoader实例对象不同，那么这两个类对象也是不相等的。 JVM必须知道一个类型是由启动加载器加载的还是由用户类加载...
类的被动使用以及实战
实践求真知
08-15 330
一 点睛 除了类的主动使用，其他的情况均属于类的被动使用。被动使用不会引起类的初始化。也就是说：并不是在代码中出现的类，就一定会被加载或者初始化。如果不符合主动使用的条件，类就不会初始化。 1 静态字段 当通过子类引用父类的静态变量，不会导致子类初始化，只有真正声明这个字段的类才会被初始化。 2 数组定义 通过数组定义类引用，不会触发此类的初始化 3 引用常量 引用常量不会触发此类或接口的初始化。因为常量在链接阶段就已经被显式赋值了。 4 loadClass 方法 调用 ClassLoad
深入剖析JVM类加载机制：原理与实战详解
- **概述**：JVM在运行时将描述类的Class文件加载到内存中，这个过程包括校验、转换解析和初始化，最终形成可以被虚拟机直接使用的Java类型。与C++等语言不同，Java的类加载、连接和初始化是在程序运行时动态进行的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值