04. 类初始化

于 2020-02-11 10:26:36 发布
阅读量179 收藏
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ZJ__ZFH/article/details/104259492
版权

类的初始化步骤

  • 假如这个类还没有被加载和连接，那就先进行加载和连接
  • 假如这个类存在直接父类，而且这个父类还没有被初始化，那就先初始化直接父类
  • 假如类中存在初始化语句，那就依次执行这些初始化语句

类的初始化时机

主动使用(七种)

  • 创建类的实例
  • 访问某个类或接口的静态变量，或者对该静态变量赋值
  • 调用类的静态方法
  • 反射(如Class.forName("com.test.Test"))
  • 初始化一个类的子类
  • Java虚拟机启动时被标明为启动类的类(Test类包含main()方法，使用Java Test启动)
  • JDK1.7开始提供的动态语言支持，java.lang.invoke.MethodHandle实例的解析结果REF_getStatic,REF_putStatic,REF_invokeStatic句柄对应的类没有初始化，则初始化

除了以上七种情况，其他使用Java类的方式都被看作是对类的被动使用，都不会导致类的初始化

当Java虚拟机初始化一个类时，要求它的所有父类都已经被初始化，但是这条规则并不适用于接口

  • 在初始化一个类时，并不会先初始化它所实现的接口
  • 在初始化一个接口时，并不会先初始化它的父接口

因此，一个父接口并不会因为它的子接口或者实现类的初始化而初始化，只有当程序首次使用特定的接口的静态变量时，才会导致该接口的初始化

只有当程序访问的静态变量或静态方法确实在当前类或当前接口中定义时，才可以认为是对类或接口的主动使用

调用ClassLoader类的loadClass方法加载一个类，并不是对类的主动使用，不会导致类的初始化

类的初始化

在初始化阶段，Java虚拟机执行类的初始化语句，为类的静态变量赋予初始值。在程序中，静态变量的初始化两种途径

  1. 在静态变量的声明处进行初始化
  2. 在静态代码块中进行初始化
public class Sample {
    private static int a = 1;
    private static long b;
    private static long c;

    static {
        b = 2;
    }
}

例如在上述代码中，静态变量a和b都被显式初始化，而静态变量c没有被显式初始化，它将保持默认值0，再如下面这个例子

public class MyTest1 {
    public static void main(String[] args) {
        System.out.println(MyChild1.str2);
    }
}

class MyParent1 {
    public static String str = "Hello World";
    static {
        System.out.println("MyParent1 static block");
    }
}

class MyChild1 extends MyParent1 {
    public static String str2 = "Welcome";
    static {
        System.out.println("MyChild1 static block");
    }
}
/*
 对于静态字段来说，只有直接定义了该字段的类才会被初始化
 当一个类在初始化时，要求其父类全部都已经初始化完毕了
 -XX:+TraceClassLoading 用于追踪类的加载信息并打印出来
 -XX:+TraceClassUnloading 用于追踪类的卸载信息并打印出来

 -XX:+<option> 表示开启option选项
 -XX:-<option> 表示关闭option选项
 -xx:<option>=<value> 表示将option选项的值设置为value
 */

可以运行下这个程序，看看输出结果，会出现这个结果的原因是，对于静态字段来说，只有直接定义了该字段的类才会被初始化

静态变量的声明语句，以及静态代码块都被看作类的初始化语句，Java虚拟机会按照初始化语句在类文件的先后顺序依次执行它们，例如

public class Sample {
    private static int a = 1;

    static {
        a = 2;
    }
    static {
        a = 4;
    }

    public static void main(String[] args) {
        System.out.println("a = " + a);
    }
}

当上述代码的Sample类被初始化后，它的静态变量a的取值为4，再如下面这个代码，有两个Singleton类是注释的，可以打开注释运行下程序，看看结果

/*
 答案 2，0
 分析如下
 Singleton singleton = Singleton.getInstance();
 调用了类的静态方法，会对类进行初始化，分准备阶段和初始化阶段
 准备阶段
    counter1 = 0
    singleton = null
    私有构造方法不执行
    counter2 = 0
 初始化阶段，按照代码顺序进行初始化
    counter1 = 1
    singleton = new Singleton()会执行私有构造器，counter1 = 2，counter2 = 1
    counter2 = 0
 所以，答案是2，0
 */
public class MyTest6 {
    public static void main(String[] args) {
        Singleton singleton = Singleton.getInstance();
        System.out.println("Singleton.counter1 = " + Singleton.counter1);
        System.out.println("Singleton.counter2 = " + Singleton.counter2);
    }
}

class Singleton {
    public static int counter1 = 1;

    private static Singleton singleton = new Singleton();

    private Singleton() {
        counter1++;
        counter2++;
    }

    public static int counter2 = 0;

    public static Singleton getInstance() {
        return singleton;
    }
}

/*
class Singleton {
    public static int counter1;
    public static int counter2 = 0;

    private static Singleton singleton = new Singleton();

    private Singleton() {
        counter1++;
        counter2++;
    }

    public static Singleton getInstance() {
        return singleton;
    }
}
 */

/*
class Singleton {
    public static int counter1;

    private static Singleton singleton = new Singleton();

    private Singleton() {
        counter1++;
        counter2++;
    }

    public static int counter2 = 0;

    public static Singleton getInstance() {
        return singleton;
    }
}
 */

对于常量来说，当一个常量的值在编译期间可以确定，那么常量在编译阶段会存入到调用这个常量的方法所在的类的常量池中，本质上，调用类并没有直接引用到定义常量的类，因此不会触发定义常量的类的初始化。当一个常量的值并非编译期间可以确定的，那么其值就不会被放到调用类的常量池中，这时在程序运行时，会导致主动使用这个常量所在的类，显然会导致这个类被初始化。具体看下面两个例子

/*
  常量在编译阶段会存入到调用这个常量的方法所在的类的常量池中，本质上，调用类并没有直接引用
  到定义常量的类，因此不会触发定义常量的类的初始化
  注意：这里指的是将常量存放到了MyTest2的常量池中，之后MyTest2与MyParent2就没有任何关系了，
  甚至，我们可以将MyParent2的class文件删除
 */
public class MyTest2 {
    public static void main(String[] args) {
        System.out.println(MyParent2.str);
        System.out.println(MyParent2.s1);
        System.out.println(MyParent2.s2);
        System.out.println(MyParent2.i1);
        System.out.println(MyParent2.i2);
    }
}

class MyParent2 {
    public static final String str = "Hello World";
    public static final short s1 = 7;
    public static final short s2 = 128;
    public static final int i1 = 0;
    public static final int i2 = -2;
    static {
        System.out.println("MyParent2 static block");
    }
}

import java.util.UUID;
/*
 当一个常量的值并非编译期间可以确定的，那么其值就不会被放到调用类的常量池中，这时在程序运行时，会导致主动
 使用这个常量所在的类，显然会导致这个类被初始化
 */
public class MyTest3 {
    public static void main(String[] args) {
        System.out.println(MyParent3.str);
    }
}

class MyParent3{
    public static final String str = UUID.randomUUID().toString().replace("-", "");
    static {
        System.out.println("MyParent3 static block");
    }
}

对于数组来说，对于数组实例来说，其类型是由JVM在运行期动态生成的，表示为[Lcom.zj.study.jvm.classloader.MyParent4这种形式。动态生成的类型，其父类型就是Object
JavaDoc经常将构成数组的元素称为Component，实际上就是将数组降低一个维度后的类型，看代码

public class MyTest4 {
    public static void main(String[] args) {
        MyParent4[] myParent4s = new MyParent4[10];
        // [Lcom.zj.study.jvm.classloader.MyParent4 表示一个具体的类型，是java虚拟机在运行期生成出来的，显然是一个数组类型，有点类似动态代理
        System.out.println(myParent4s.getClass());
        System.out.println(myParent4s.getClass().getSuperclass());
        System.out.println("=================");

        MyParent4[][] myParent4ss = new MyParent4[10][10];
        // [Lcom.zj.study.jvm.classloader.MyParent4 表示一个具体的类型，是java虚拟机在运行期生成出来的，显然是一个数组类型，有点类似动态代理
        System.out.println(myParent4ss.getClass());
        System.out.println(myParent4ss.getClass().getSuperclass());
        System.out.println("=================");

        int[] intNums = new int[100];
        System.out.println(intNums.getClass());
        System.out.println(intNums.getClass().getSuperclass());
        System.out.println("=================");

        Integer[] intNumss = new Integer[100];
        System.out.println(intNumss.getClass());
        System.out.println(intNumss.getClass().getSuperclass());
        System.out.println("=================");
    }
}

class MyParent4{
    static {
        System.out.println("MyParent4 static block");
    }
}

当Java虚拟机初始化一个类时，要求它的所有父类都已经被初始化

使用子类去访问父类的静态变量/静态方法，本质上表示对父类的主动使用，而不是对子类的主动使用，定义在谁身上，表示对谁的主动使用

看下代码

public class MyTest9 {
    static {
        System.out.println("MyTest9 static block");
    }

    public static void main(String[] args) {
        System.out.println(MyChild9.b);
    }
}

class MyParent9{
    static int a = 3;

    static {
        System.out.println("MyParent9 static block");
    }
}

class MyChild9 extends MyParent9 {

    static int b = 4;

    static {
        System.out.println("MyChild9 static block");
    }
}

分析下程序的运行结果，再看下一个代码

public class MyTest10 {
    static {
        System.out.println("MyTest10 static block");
    }

    /*
        MyTest10 static block
        --------
        MyParent10 static block
        --------
        3
        --------
        MyChild10 static block
        4
     */
    public static void main(String[] args) {
        MyParent10 myParent10;
        System.out.println("--------");
        myParent10 = new MyParent10();
        System.out.println("--------");
        System.out.println(myParent10.a);
        System.out.println("--------");
        System.out.println(MyChild10.b);
    }
}

class MyParent10{
    static int a = 3;

    static {
        System.out.println("MyParent10 static block");
    }
}

class MyChild10 extends MyParent10 {

    static int b = 4;

    static {
        System.out.println("MyChild10 static block");
    }
}

分析下运行的结果，在看一个例子

// 使用子类去访问父类的静态变量/静态方法，本质上表示对父类的主动使用，而不是对子类的主动使用
// 定义在谁身上，表示对谁的主动使用
public class MyTest11 {
    /*
    MyParent11 static block
    3
    do something
     */
    public static void main(String[] args) {
        System.out.println(MyChild11.a);
        MyChild11.doSomething();
    }
}

class MyParent11 {
    static int a = 3;
    static {
        System.out.println("MyParent11 static block");
    }

    static void doSomething() {
        System.out.println("do something");
    }
}

class MyChild11 extends MyParent11 {
    static {
        System.out.println("MyChild11 static block");
    }
}

分析运行的结果，这是因为，使用子类去访问父类的静态变量/静态方法，本质上表示对父类的主动使用，而不是对子类的主动使用，定义在谁身上，表示对谁的主动使用

当Java虚拟机初始化一个类时，要求它的所有父类都已经被初始化，但是这条规则并不适用于接口

  • 在初始化一个类时，并不会先初始化它所实现的接口
  • 在初始化一个接口时，并不会先初始化它的父接口

因此，一个父接口并不会因为它的子接口或者实现类的初始化而初始化，只有当程序首次使用特定的接口的静态变量时，才会导致该接口的初始化

只有当程序访问的静态变量或静态方法确实在当前类或当前接口中定义时，才可以认为是对类或接口的主动使用，看例子

看例子之前，先明白实例化代码块与静态代码块的区别，

class C {
    // 实例化代码块，每一个C的实例被创建时都会执行
    {
        System.out.println("Hello");
    }

    // 静态代码块，仅仅会执行一次
    static {
        System.out.println("Static ");
    }

    public C() {
        System.out.println("C");
    }
}

为了验证接口有没有没初始化，定义了如下类似的接口

interface MyParent5 {
    // 如果MyParent5被初始化了，那么thread一定会被赋值，那么必会创建一个匿名对象
    // 代码块会被执行 MyParent5 invoked会被执行
    public static final Thread thread = new Thread() {
        {
            System.out.println("MyParent5 invoked");
        }
    };
}

首先看下，在初始化一个类时，并不会先初始化它所实现的接口，上代码

public class MyTest5 {
    public static void main(String[] args) {
        System.out.println(MyChild5.b);
        System.out.println(MyChild5.thread);
    }
}

// 在初始化一个类时，并不会先初始化它所实现的接口
interface MyParent5 {
    // 如果MyParent5被初始化了，那么thread一定会被赋值，那么必会创建一个匿名对象
    // 代码块会被执行
    public static final Thread thread = new Thread() {
        {
            System.out.println("MyParent5 invoked");
        }
    };
}

class MyChild5 implements MyParent5 {
    public static int b = 5;
}

分析以上代码，看运行结果，当一个接口在初始化时，并不要求其父接口都完成了初始化，只有在真正使用到父接口的时候(如引用接口中所定义的常量时)，才会初始化，接口定义的变量，本身就是public static final修饰的，本身就是常量

再来看下，在初始化一个接口时，并不会先初始化它的父接口

public class MyTest5_1 {
    public static void main(String[] args) {
        System.out.println(NewMyParent5.thread);
    }
}

// 在初始化一个接口时，并不会先初始化它的父接口
interface NewMyParent5 extends NewMyGradPa5 {
    public static Thread thread = new Thread() {
        {
            System.out.println("NewMyParent5 invoked");
        }
    };
}

interface NewMyGradPa5 {
    public static Thread thread = new Thread() {
        {
            System.out.println("NewMyGradPa5 invoked");
        }
    };
}

分析以上代码，看运行结果

ZFH__ZJ
关注
12、Java基础---类初始化器和实例初始化器
姜皓的博客
09-22 1158
类初始化器和实例初始化器 一、类初始化器（静态初始化器） 我们来回忆一下上一篇创建的类Id，每创建一个类的实例，都会为其赋上连续的标识编号1、2、3······ 这里对该类进行修改，使得标识编号的开始编号并不是1, 而是一个随机数值， 程序如下： // 标识编号类（通过随机数来设定开始编号） import java.util.Random; class RandId { private...
初始化模型参数 python_【深度学习】模型参数访问、初始化和共享（Pythorch）,的,pyTorch...
weixin_39673704的博客
12-12 732
程序主要使用到的函数总结如下：# 1 访问模型参数for name, param in net.named_parameters():for param in net.parameters():self.weight1 = nn.Parameter(torch.rand(20,20))# 2 初始化模型参数init.normal_(param, mean = 0, std = 0.01)init....
java 类的初始化
11-14 125
Java类的初始化 我们知道一个类(class)要被使用必须经过装载，连接，初始化这样的过程。下面先对这三阶段做一个简单的描述，之后会结合一个简单的例子来说明java中类的初始化过程。 在装载阶段，类装载器(Bootstrap ClassLoader 或者用户自定义的ClassLoader) 把编译形成的class文件载入内存，创建类相关的Class对象，这个Class对象封装...
类的初始化
java开发指南博客 【转载】
06-30 166
类的初始化通产有3种类型：使用初始化列表，在构造函数体中赋值，以及使用默认构造函数。 先说前两种： 初始化列表与在构造函数体中赋值的区别在哪里呢？主要有两点： 第一，有的成员不能使用函数体中的“=”初始化。这其实就是初始化与赋值的区别：比如比如const 成员，引用类型，以及没有定义默认构造函数的类，它们都必须在定义时初始化，而不能赋值，这时候我们的初始化列表就派上用场了。 第二，初始化的...
Spring Boot解决项目启动时初始化资源的方法
08-27
Spring Boot 解决项目启动时初始化资源的方法 在本文中，我们将介绍 Spring Boot 如何解决项目启动时初始化资源的方法。通过示例代码，我们将详细介绍 CommandLineRunner 的使用方法，帮助大家解决项目启动初始化...
2.OkHttp的初始化
Mirs的博客
06-29 2219
2.OkHttp的初始化OkHttp的整个的初始化采用了一个Builder的形式来建造，对设计模式不太了解的同学可以去看https://github.com/mirsfang/ExamplesOfDesignPatterns接下来进入正题OkHttpClient的初始化OkHttpClient在代码中是这样的 OkHttpClient okHttpClient=new OkHttpClient.Bu
测试开发【Mock平台】04实战：前后端项目初始化与登录鉴权实现.doc
07-08
【Mock 平台】实战教程主要分为前后端项目初始化与登录鉴权的实现。这个教程旨在帮助测试开发者从零开始构建一个基于 Spring Boot 和 Antd React 的测试工具平台。通过这个实战项目，你可以学习到如何有效地组织代码...
类初始化
amyli的专栏
05-20 963
加载阶段，java虚拟机规范中并没有进行强制约束； 但初始化阶段，虚拟机规范则严格规定了有且只有5种情况必须立即对类进行“初始化”； 1）遇到new，getstatic，putstatic 或invokestatic指令，如果类没有进行过初始化，则需要先触发初始化； 即使用new 实例化对象，读取或设置一个类的静态变量（被final修饰，已在编译期把结果放入常量池的静态字段除外）的时
类的初始化过程
zhzhao的博客
11-30 551
子父类的初始化过程(分层初始化):父类初始化 --> 子类初始化 注意 :虽然子类的构造方法中,默认第一行是super(), 但是,并不表示走完super()后,接着走子类构造方法中的其他内容. 仅仅表示要先初始化父类数据,再初始化子类数据. 也就是说,super()表示的是分层初始化. 类的初始化过程:（静态变量、静态初始化块）-->（变量、初始化块）--> 构造方法 注意 :括号内的按写的先后顺
CameraX类需要初始化哪些
最新发布
10-10
使用CameraX进行摄像头操作之前，通常需要经过以下步骤的初始化： 1. **添加依赖**：首先在build.gradle文件中添加CameraX的依赖，如果使用的是Gradle插件，则可以在`dependencies`块中加入： ```groovy ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值