类初始化过程

最新推荐文章于 2022-04-21 09:09:23 发布
最新推荐文章于 2022-04-21 09:09:23 发布
阅读量207 收藏 1
点赞数
分类专栏： 面试题 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/lijunpeng71/article/details/114040944
版权

类初始化过程

由一个面试题开始，此段代码输出的结果

public class Father {

    private int i = test();

    private static int j = method();

    /**
     * 静态代码块
     */
    static {
        System.out.println("(1)");
    }

    /**
     * 父类构造方法
     */
    Father() {
        System.out.println("(2)");
    }

    /**
     * 普通代码块
     */ {
        System.out.println("(3)");
    }

    /**
     * 普通方法
     *
     * @return
     */
    public int test() {
        System.out.println("(4)");
        return 1;
    }

    /**
     * 静态方法
     *
     * @return
     */
    public static int method() {
        System.out.println("(5)");
        return 1;
    }
}

public class Son extends Father {

    private int i = test();

    private static int j = method();

    /**
     * 静态代码块
     */
    static {
        System.out.println("(6)");
    }

    /**
     * 构造代码块
     */
    Son() {
        System.out.println("(7)");
    }

    /**
     * 普通代码块
     */ {
        System.out.println("(8)");
    }


    /**
     * 普通方法
     *
     * @return
     */
    public int test() {
        System.out.println("(9)");
        return 1;
    }

    /**
     * 静态方法
     *
     * @return
     */
    public static int method() {
        System.out.println("(10)");
        return 1;
    }

    public static void main(String[] args) {

    }
}

输出结果：（5）（1）（10）（6）

类初始化过程

  1. 一个类药创建实例需要先加载并初始化该类
    main方法所在的类需要先加载和初始化
  2. 一个子类要初始化需要先初始化父类
  3. 一个类初始化就是执行"<clinit>()"方法
    <clinit>()方法由静态变量显示赋值代码和静态代码块组成
    类变量显示赋值代码和静态代码块代码从上到下顺序执行
    <clinit>()方法只执行一次

通过字节码查看

Compiled from "Father.java"
public class com.study.interview.classload.Father {
  private int i;

  private static int j;

  com.study.interview.classload.Father();
    Code:
       0: aload_0
       1: invokespecial #1                  // Method java/lang/Object."<init>":()V
       4: aload_0
       5: aload_0
       6: invokevirtual #2                  // Method test:()I
       9: putfield      #3                  // Field i:I
      12: getstatic     #4                  // Field java/lang/System.out:Ljava/io/PrintStream;
      15: ldc           #5                  // String (3)
      17: invokevirtual #6                  // Method java/io/PrintStream.println:(Ljava/lang/String;)V
      20: getstatic     #4                  // Field java/lang/System.out:Ljava/io/PrintStream;
      23: ldc           #7                  // String (2)
      25: invokevirtual #6                  // Method java/io/PrintStream.println:(Ljava/lang/String;)V
      28: return

  public int test();
    Code:
       0: getstatic     #4                  // Field java/lang/System.out:Ljava/io/PrintStream;
       3: ldc           #8                  // String (4)
       5: invokevirtual #6                  // Method java/io/PrintStream.println:(Ljava/lang/String;)V
       8: iconst_1
       9: ireturn

  public static int method();
    Code:
       0: getstatic     #4                  // Field java/lang/System.out:Ljava/io/PrintStream;
       3: ldc           #9                  // String (5)
       5: invokevirtual #6                  // Method java/io/PrintStream.println:(Ljava/lang/String;)V
       8: iconst_1
       9: ireturn

  static {};
    Code:
       0: invokestatic  #10                 // Method method:()I
       3: putstatic     #11                 // Field j:I
       6: getstatic     #4                  // Field java/lang/System.out:Ljava/io/PrintStream;
       9: ldc           #12                 // String (1)
      11: invokevirtual #6                  // Method java/io/PrintStream.println:(Ljava/lang/String;)V
      14: return
}


Compiled from "Son.java"
public class com.study.interview.classload.Son extends com.study.interview.classload.Father {
  private int i;

  private static int j;

  com.study.interview.classload.Son();
    Code:
       0: aload_0
       1: invokespecial #1                  // Method com/study/interview/classload/Father."<init>":()V
       4: aload_0
       5: aload_0
       6: invokevirtual #2                  // Method test:()I
       9: putfield      #3                  // Field i:I
      12: getstatic     #4                  // Field java/lang/System.out:Ljava/io/PrintStream;
      15: ldc           #5                  // String (8)
      17: invokevirtual #6                  // Method java/io/PrintStream.println:(Ljava/lang/String;)V
      20: getstatic     #4                  // Field java/lang/System.out:Ljava/io/PrintStream;
      23: ldc           #7                  // String (7)
      25: invokevirtual #6                  // Method java/io/PrintStream.println:(Ljava/lang/String;)V
      28: return

  public int test();
    Code:
       0: getstatic     #4                  // Field java/lang/System.out:Ljava/io/PrintStream;
       3: ldc           #8                  // String (9)
       5: invokevirtual #6                  // Method java/io/PrintStream.println:(Ljava/lang/String;)V
       8: iconst_1
       9: ireturn

  public static int method();
    Code:
       0: getstatic     #4                  // Field java/lang/System.out:Ljava/io/PrintStream;
       3: ldc           #9                  // String (10)
       5: invokevirtual #6                  // Method java/io/PrintStream.println:(Ljava/lang/String;)V
       8: iconst_1
       9: ireturn

  public static void main(java.lang.String[]);
    Code:
       0: return

  static {};
    Code:
       0: invokestatic  #10                 // Method method:()I
       3: putstatic     #11                 // Field j:I
       6: getstatic     #4                  // Field java/lang/System.out:Ljava/io/PrintStream;
       9: ldc           #12                 // String (6)
      11: invokevirtual #6                  // Method java/io/PrintStream.println:(Ljava/lang/String;)V
      14: return
}

子类初始化的时候，先初始化父类

另一个面试题结束，此段代码输出的结果

/**
*	Father类不变
*/
public class Son extends Father {

    private int i = test();

    private static int j = method();

    /**
     * 静态代码块
     */
    static {
        System.out.println("(6)");
    }

    /**
     * 构造代码块
     */
    Son() {
        System.out.println("(7)");
    }

    /**
     * 普通代码块
     */ {
        System.out.println("(8)");
    }


    /**
     * 普通方法
     *
     * @return
     */
    public int test() {
        System.out.println("(9)");
        return 1;
    }

    /**
     * 静态方法
     *
     * @return
     */
    public static int method() {
        System.out.println("(10)");
        return 1;
    }

    public static void main(String[] args) {
    	//新增代码
        Son son1 = new Son();
        System.out.println();
        Son son2 = new Son();
    }
}

输出结果:
(5) (1) (10) (6) (9) (3) (2) (9) (8) (7)
(9) (3) (2) (9) (8) (7)

实例初始化过程

  1. 实例初始化及时执行<init>()方法
    <init>()方法可能重载有多个，有几个构造器就有几个&ltinit>()方法
    <init>()方法由非静态实例变量显示赋值代码和非静态代码块、对应构造代码组成
    非静态实例变量显示赋值代码和非静态代码块代码从上到下顺序执行，而对应构造器的代码最后 执 行
    每次创建实例对象，调用对象构造器，执行的就是对应<init>方法
    <init>方法的首行是super()或super(实参列表),即对应的<init>方法
  2. 方法的重写
    不能被重写的方法有： final方法、静态方法、private等子类中不可见方法
    能够重写的方法：public修饰的方法、默认方法
  3. 对象的多态
    子类如果重写了父类的方法，通过子类对象调用的一定是子类重写过的代码
    非静态方法默认的调用对象是this
    this对象在构造器或者<init>方法中就是正在创建的对象 如：在创建Son方法的时候，需要先构造父类方法，此时this代表的是Son的实例
lijunpeng71
关注
专栏目录
简述类的加载过程
DONG__CHI的博客
03-04 715
简述类的加载过程 ​ 如下图所示，JVM加载机制 分为五个部分：加载，验证，准备，解析，初始化。下面而分别分析一下这五个过程。 加载 ​ 加载时类的加载过程中的一个阶段，这个阶段会在内存中生成代表这个类的java.lang.Class对象，作为方法区这个类的个中数据的入口。注意这里不一定非得从一个Class文件获取，这里既可以从ZIP包中读取（比如从jar包和war包中读取），也可以在运行时计算...
JVM类初始化过程
小海豚の家
11-13 885
JVM类初始化过程 类加载机制 **类加载机制主要有三步: 加载、连接、初始化。 ** 加载 ​ 把编译好的class文件加载进内存 (1.7及之前为方法区，1.8取消方法区，用元数据区替代) 中，并在堆中创建对应的Class对象。 连接 验证 ​ 验证加载的类信息是否符合JVM规范，确保安全 准备 ​ 为静态变量分配内存并设置默认的初始值 解析 ​ 将类的二进制数据中的符号引用替换成直接引用 初始化 ​ 静态变量赋值 -> 静态代码块 -> 成员变量 ->
类的初始化过程
孤海岛主
10-28 296
1、一个类要创建实例需要先加载并初始化该类 main方法所在的类需要先加载和初始化 2、一个子类要初始化需要先初始化其父类 3、一个类的初始化就是执行<clinit>()方法 <clinit>()方法由静态类变量显示赋值代码和静态代码块组成 类变量显示赋值代码和静态代码块代码从上到下顺序执行 <clinit>()方法只执行一次 ...
类初始化流程
l1394049664的博客
07-27 3937
一、类的初始化顺序（静态变量、静态初始化块：决于它们在类中出现的先后顺序）&gt;（变量、初始化块：决于它们在类中出现的先后顺序）&gt;构造器 原理： 1、加载类信息。在实例化对象之前，类的装载器会找到需要加载的类class文件，进行类的加载（有父类的会先加载父类），一旦加载到最根上的基类，就会对基类的静态变量和静态初始化块进行初始化； 2、当所有类信息加载完毕就会执行main（）主方法，然后执...
Java类初始化顺序
12-22
在实际编程中，理解类初始化顺序至关重要，因为它可以帮助避免潜在的错误和异常。例如，确保在访问成员变量前它们已被正确初始化，或者在适当的地方初始化静态变量以避免并发问题。遵循良好的编码规范，如将初始化...
java面试题-类的初始化顺序.doc
最新发布
05-10
这个顺序表明，无论类之间的继承关系如何，初始化顺序始终是：静态变量和静态初始化块先于非静态成员。在创建对象时，父类的初始化先于子类。这是Java语言规范所规定的，确保在子类访问父类的静态或非静态成员时，...
java类中元素初始化顺序详解
09-05
Java 类的初始化顺序是一个关键的编程概念，尤其对于理解和避免潜在的运行时错误至关重要。在 Java 中，类的元素初始化顺序遵循以下规则： 1. **静态变量与静态初始化块**： 首先，Java 解释器会执行类中的静态...
Java类继承关系中的初始化顺序实例详解
08-25
Java类继承关系中的初始化顺序实例详解 Java类继承关系中的初始化顺序是Java编程语言中的一個重要概念。该概念关系到类的初始化顺序，静态成员变量的初始化顺序，普通成员变量的初始化顺序等。在本文中，我们将详细...
解释类初始化过程
zcx12ZCX的博客
04-21 218
类初始化过程 1 一个类要创建实例，需要先加载并初始化该类main方法所在的类需要先加载和初始化 2 一个子类要初始化需要先初始化父类 3 一个类初始化就是执行<clinit>()方法 <clinit>()方法由静态类变量显示赋值代码和静态代码块组成 类变量显示赋值代码和静态代码块代码从上到下顺执行 <clinit>()方法只执行一次 ...
类的加载顺序
Hello,I am Waleee
06-09 405
初始化过程： 1. 初始化父类中的静态成员变量和静态代码块 ； 2. 初始化子类中的静态成员变量和静态代码块 ； 3.初始化父类的普通成员变量和代码块，再执行父类的构造方法； 4.初始化子类的普通成员变量和代码块，再执行子类的构造方法； class X{ Y y=new Y(); public X(){ System.out.print("X");
一个类被初始化的过程
我想月薪过万的博客
03-31 714
在上一讲中我们了解了JVM一个类的加载过程 ： JVM一个类的加载过程_super码王的博客-CSDN博客
类的初始化过程 （代码执行的先后顺序）
qq_40167917的博客
08-26 280
类的初始化过程也就是方法执行的过程 父类的静态变量-父类的静态代码块 子类的静态变量-子类的静态代码块 父类的非静态变量-父类的非静态代码块-父类的构造函数 子类的非静态变量-子类的非静态代码块-子类的构造函数 规律就是 父类先于子类 静态的先于非静态的 变量先于代码块 父类静态域——》子类静态域——》父类成员初始化——》父类构造块——》1父类构造方法——》2子类成员初始化——》...
Java类初始化过程
程序猿YOKO
09-09 455
学习java，对于java类的初始化过程很迷惑，不是很了解其过程，所以在网上和书籍上整理了一下。 摘自：解析 Java 类和对象的初始化过程类初始化 类”初始化”阶段，它是一个类或接口被首次使用的前阶段中的最后一项工作，本阶段负责为类变量赋予正确的初始值。 Java 编译器把所有的类变量初始化语句和类型的静态初始化器通通收集到 方法内，该方法只能被 Jvm 调用，专门承担初始化工作。 除接
Java类的初始化过程
zy512638348的博客
10-07 256
1.首先，初始化父类中的静态成员变量和静态代码块，按照在程序中出现的顺序初始化； 2.然后，初始化子类中的静态成员变量和静态代码块，按照在程序中出现的顺序初始化； 3.其次，初始化父类中的普通成员变量和代码块，再执行父类的构造方法； 4.最后，初始化子类的普通成员变量和代码块，再执行子类的构造方法； 例题，执行以下代码的输出： （1）首先初始化父类的普通成员变量和代码块，
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值