深入理解class字节码中的<init>,<clinit>

最新推荐文章于 2023-04-01 20:48:50 发布
最新推荐文章于 2023-04-01 20:48:50 发布
阅读量1.4k 收藏 2
点赞数 1
分类专栏： JVM 文章标签： JVM
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/vikenpeng/article/details/84176276
版权

        java中有两种特殊的方法<init>,<clinit> 

1,当java类中，存在用static修饰的静态类型字段，或static块，编译器便会生成<clinit>

2,当java类中定义了构造方法，或其他非static类成员变量被赋了初始值，编译器便会生成<init>

代码

public class Test{

     private Integer i=3;

     private static int a=90;

     public void add(int a,int b){

     Test test=this;

     int z=a+b;

     int x=3;

}

     public static void main(String[] args){

       Test test=new Test();

      test.add(2,3);

    }

}

 javac Test.java

 javap -verbose Test.class 如下图所示

 java成员变量，静态属性，都在常量池中

Classfile /Users/robin/Test.class

  Last modified 2018-11-16; size 570 bytes

  MD5 checksum 179494093ddd1f13d97f138f5162f8a8

  Compiled from "Test.java"

public class Test

  minor version: 0

  major version: 52

  flags: ACC_PUBLIC, ACC_SUPER

Constant pool:

   #1 = Methodref          #8.#24         // java/lang/Object."<init>":()V

   #2 = Methodref          #25.#26        // java/lang/Integer.valueOf:(I)Ljava/lang/Integer;

   #3 = Fieldref           #4.#27         // Test.i:Ljava/lang/Integer; //成员变量引用

   #4 = Class              #28            // Test

   #5 = Methodref          #4.#24    // Test."<init>":()V

   #6 = Methodref          #4.#29         // Test.add:(II)V

   #7 = Fieldref           #4.#30         // Test.a:I      

   #8 = Class              #31            // java/lang/Object

   #9 = Utf8               i

  #10 = Utf8               Ljava/lang/Integer;

  #11 = Utf8               a

  #12 = Utf8               I

  #13 = Utf8               <init>

  #14 = Utf8               ()V

  #15 = Utf8               Code

  #16 = Utf8               LineNumberTable

  #17 = Utf8               add

  #18 = Utf8               (II)V

  #19 = Utf8               main

  #20 = Utf8               ([Ljava/lang/String;)V

  #21 = Utf8               <clinit>

  #22 = Utf8               SourceFile

  #23 = Utf8               Test.java

  #24 = NameAndType        #13:#14        // "<init>":()V

  #25 = Class              #32            // java/lang/Integer

  #26 = NameAndType        #33:#34        // valueOf:(I)Ljava/lang/Integer;

  #27 = NameAndType        #9:#10         // i:Ljava/lang/Integer;

  #28 = Utf8               Test

  #29 = NameAndType        #17:#18        // add:(II)V

  #30 = NameAndType        #11:#12        // a:I 

  #31 = Utf8               java/lang/Object

  #32 = Utf8               java/lang/Integer

  #33 = Utf8               valueOf

  #34 = Utf8               (I)Ljava/lang/Integer;

{

  public Test();

    descriptor: ()V

    flags: ACC_PUBLIC

    Code:

      stack=2, locals=1, args_size=1

         0: aload_0           //加载变量表中的this 入栈

         1: invokespecial #1  //调用常量池1位置父类的init方法  // Method java/lang/Object."<init>":()V   

         4: aload_0           //加载变量表中的this 入栈  

         5: iconst_3          //加载3入栈   

         6: invokestatic  #2  //调用常量池2位置的静态方法     //Method java/lang/Integer.valueOf:(I)Ljava/lang/Integer;

         9: putfield      #3  //放到常量池3位置  // Field i:Ljava/lang/Integer;

        12: return

  public void add(int, int);

    descriptor: (II)V

    flags: ACC_PUBLIC

    Code:

      stack=2, locals=6, args_size=3

         0: aload_0

         1: astore_3

         2: iload_1

         3: iload_2

         4: iadd

         5: istore        4

         7: iconst_3

         8: istore        5

        10: return

      LineNumberTable:

        line 7: 0

        line 8: 2

        line 9: 7

        line 10: 10

  public static void main(java.lang.String[]);

    descriptor: ([Ljava/lang/String;)V

    flags: ACC_PUBLIC, ACC_STATIC

    Code:

      stack=3, locals=2, args_size=1

         0: new           #4                  // class Test

         3: dup

         4: invokespecial #5                  // Method "<init>":()V

         7: astore_1

         8: aload_1

         9: iconst_2

        10: iconst_3

        11: invokevirtual #6                  // Method add:(II)V

        14: return

      LineNumberTable:

        line 13: 0

        line 14: 8

        line 15: 14

  static {};

    descriptor: ()V

    flags: ACC_STATIC

    Code:

      stack=1, locals=0, args_size=0

         0: bipush        90

         2: putstatic     #7                  // Field a:I

         5: return

      LineNumberTable:

        line 4: 0

}

jdb命令打断点调试

UseCompressedOops 取消指针压缩功能

1，jdb -XX:+UseSerialGC -Xmx10m -XX:-UseCompressedOops

2，stop in Test.add  表示在Test类的add方法设断点

3,   run Test     开始启动Test类的main方法，Test的main运行后，jdb会在add方法的第一行代码上暂停

4，next，会进入到add方法的第二句代码

执行jps，查看进程号 ，sudo java -cp sa-jdi.jar sun.jvm.hotspot.HSDB

1，查看堆内存 universe

universe

Heap Parameters:

Gen 0:   eden [0x000000011f800000,0x000000011f9458e0,0x000000011fab0000) space capacity = 2818048, 47.31899527616279 used

  from [0x000000011fab0000,0x000000011fab0000,0x000000011fb00000) space capacity = 327680, 0.0 used

  to   [0x000000011fb00000,0x000000011fb00000,0x000000011fb50000) space capacity = 327680, 0.0 usedInvocations: 0

Gen 1:   old  [0x000000011fb50000,0x000000011fb50000,0x0000000120200000) space capacity = 7012352, 0.0 usedInvocations: 0

hsdb>

2,搜索实例 scanoops 

 果然找到了Test的实例 地址 0x000000011f941720   scanoops 命令会显示该实例在JVM 内部对应的instanceOop的内存首地址

hsdb> scanoops 0x000000011f800000 0x0000000120200000 Test

0x000000011f941720 Test

3,选择tools->inspect

4, 查看类的<init>,<clinit> 

    tools-> class brower

 

问题：jvm为什么需要编译器自动生成这2个方法？

答：1，<init>方法等同于类的构造函数，在遇到new指令时，自然会调用该方法

        2，java类中存在static成员变量，或者有static{}的代码块时，jvm加载java类时，会触发<clinit>方法，完成static成员变量的初始化，或者执行static{}的代码逻辑

 

<init>详解

  在上面的Test例子中，并没有显式定义构造方法，但是编译器还是生成了一个构造方法，

 1,如果我们显式的定义了一个构造方法

public class Test{

     private Integer i=3;

     private static int a=90;

     public Test(){

      short s=8;

      }

     public void add(int a,int b){

     Test test=this;

     int z=a+b;

     int x=3;

}

     public static void main(String[] args){

     Test test=new Test();

     test.add(2,3);

    }

修改之前的

public Test();

    descriptor: ()V

    flags: ACC_PUBLIC

    Code:

      stack=2, locals=1, args_size=1

         0: aload_0           //加载变量表中的this 入栈

         1: invokespecial #1  //调用常量池1位置父类的init方法  // Method java/lang/Object."<init>":()V   

         4: aload_0           //加载变量表中的this 入栈  

         5: iconst_3          //加载3入栈   

         6: invokestatic  #2  //调用常量池2位置的静态方法     //Method java/lang/Integer.valueOf:(I)Ljava/lang/Integer;

         9: putfield      #3  //放到常量池3位置  // Field i:Ljava/lang/Integer;

        12: return

查看字节码

{

  public Test();

    descriptor: ()V

    flags: ACC_PUBLIC

    Code:

      stack=2, locals=2, args_size=1

         0: aload_0

         1: invokespecial #1                  // Method java/lang/Object."<init>":()V

         4: aload_0

         5: iconst_3

         6: invokestatic  #2                  // Method java/lang/Integer.valueOf:(I)Ljava/lang/Integer;

         9: putfield      #3                  // Field i:Ljava/lang/Integer;

        12: bipush        8                   //将8载入操作数栈 

        14: istore_1                          //存入变量表1位置  

        15: return

}

结论：即使定义了一个构造方法，也不会影响<init>方法，依然会将成员变量的初始化指令加到构造方法的字节码指令中

2,加入一段{}代码块

public class Test{

     private Integer i=3;

     private static int a=90;

    {

     System.out.println("i="+i);

    }

     public Test(){

         short s=8;

      }

     public Test(int x){

        x=12;

    }

     public void add(int a,int b){

     Test test=this;

     int z=a+b;

     int x=3;

     }

 

     public static void main(String[] args){

     Test test=new Test();

     test.add(2,3);

    }

}

字节码内容

{

  public Test();

    descriptor: ()V

    flags: ACC_PUBLIC

    Code:

      stack=3, locals=2, args_size=1

         0: aload_0

         1: invokespecial #1                  // Method java/lang/Object."<init>":()V

         4: aload_0

         5: iconst_3

         6: invokestatic  #2                  // Method java/lang/Integer.valueOf:(I)Ljava/lang/Integer;

         9: putfield      #3     //赋给成员变量值  // Field i:Ljava/lang/Integer;

        //这一段就是{}的执行字节码

        12: getstatic     #4                  // Field java/lang/System.out:Ljava/io/PrintStream;

        15: new           #5                  // class java/lang/StringBuilder

        18: dup

        19: invokespecial #6                  // Method java/lang/StringBuilder."<init>":()V

        22: ldc           #7                  // String i=

        24: invokevirtual #8                  // Method java/lang/StringBuilder.append:(Ljava/lang/String;)Ljava/lang/StringBuilder;

        27: aload_0

        28: getfield      #3                  // Field i:Ljava/lang/Integer;

        31: invokevirtual #9                  // Method java/lang/StringBuilder.append:(Ljava/lang/Object;)Ljava/lang/StringBuilder;

        34: invokevirtual #10                 // Method java/lang/StringBuilder.toString:()Ljava/lang/String;

        37: invokevirtual #11                 // Method java/io/PrintStream.println:(Ljava/lang/String;)V

        40: bipush        8                   // short s=8

        42: istore_1

        43: return

  public Test(int);

    descriptor: (I)V

    flags: ACC_PUBLIC

    Code:

      stack=3, locals=2, args_size=2

         0: aload_0

         1: invokespecial #1                  // Method java/lang/Object."<init>":()V

         4: aload_0

         5: iconst_3

         6: invokestatic  #2                    // Method java/lang/Integer.valueOf:(I)Ljava/lang/Integer;

         9: putfield      #3    //赋给成员变量值  // Field i:Ljava/lang/Integer;

        12: getstatic     #4                   // Field java/lang/System.out:Ljava/io/PrintStream;

        15: new           #5                   // class java/lang/StringBuilder

        18: dup

        19: invokespecial #6                  // Method java/lang/StringBuilder."<init>":()V

        22: ldc           #7                  // String i=

        24: invokevirtual #8                  // Method java/lang/StringBuilder.append:(Ljava/lang/String;)Ljava/lang/StringBuilder;

        27: aload_0

        28: getfield      #3                  // Field i:Ljava/lang/Integer;

        31: invokevirtual #9                  // Method java/lang/StringBuilder.append:(Ljava/lang/Object;)Ljava/lang/StringBuilder;  

        34: invokevirtual #10                 // Method java/lang/StringBuilder.toString:()Ljava/lang/String;

        37: invokevirtual #11                 // Method java/io/PrintStream.println:(Ljava/lang/String;)V

        40: bipush        12

        42: istore_1

        43: return

 

总结，从上面的代码，可以看出{}代码的字节码，在两个构造方法都有，进一步地说明，通过new指令，调用构造方法时，都会执行{}代码块

3，加入一个父类 BaseClass.java

public abstract class BaseClass{

    protected long plong=12l;

     static{

      Integer i=30;

    }

}

{

  protected long plong;

    descriptor: J

    flags: ACC_PROTECTED

 

  public BaseClass();

    descriptor: ()V

    flags: ACC_PUBLIC

    Code:

      stack=3, locals=1, args_size=1

         0: aload_0

         1: invokespecial #1                  // Method java/lang/Object."<init>":()V

         4: aload_0

         5: ldc2_w        #2                  // long 12l

         8: putfield      #4                  // Field plong:J

        11: return

  static {};

    descriptor: ()V

    flags: ACC_STATIC

    Code:

      stack=1, locals=1, args_size=0

         0: bipush        30

         2: invokestatic  #5       //Integer i=30;    // Method java/lang/Integer.valueOf:(I)Ljava/lang/Integer;

         5: astore_0               //保存到本地变量表中

         6: return

}

查看字节码Test.class

{

  public Test();

    descriptor: ()V

    flags: ACC_PUBLIC

    Code:

      stack=2, locals=2, args_size=1

         0: aload_0

         1: invokespecial #1                  // Method BaseClass."<init>":()V

         4: aload_0

         5: iconst_3

         6: invokestatic  #2                  // Method java/lang/Integer.valueOf:(I)Ljava/lang/Integer;

         9: putfield      #3                  // Field i:Ljava/lang/Integer;

        12: bipush        8

        14: istore_1

        15: return

 public Test(int);

    descriptor: (I)V

    flags: ACC_PUBLIC

    Code:

      stack=2, locals=2, args_size=2

         0: aload_0

         1: invokespecial #1                  // Method BaseClass."<init>":()V

         4: aload_0

         5: iconst_3

         6: invokestatic  #2                  // Method java/lang/Integer.valueOf:(I)Ljava/lang/Integer;

         9: putfield      #3                  // Field i:Ljava/lang/Integer;

        12: bipush        12

        14: istore_1

        15: return

static {};

    descriptor: ()V

    flags: ACC_STATIC

    Code:

      stack=1, locals=0, args_size=0

         0: bipush        90

         2: putstatic     #7                  // Field a:I

         5: return

结论：子类的构造方法，都会先去调用父类的<init>方法，

解释{}与static{}的作用域

1，{}块：

   能够访问java类的非静态成员变量，和静态成员变量，但是其内部定的变量不能被外部所访问，但是{}块的局部变量在编译期会放到本地变量表，而本地变量表又是方法相关的，但是{}块并不一个方法，java编译器将{}块嵌入到<init>方法，因此这个本地变量表，就是java类的构造方法的，

测试当有多个{}块

public class Test extends BaseClass {

     private Integer i=3;

     private static int a=90;

    {

     int a=1;

    int b=2;

    int c=a+b;

     }

    {

    int d=3;

    int e=4;

    int f=e-d;

}

     public Test(){

      short s=8;

      }

}

{

  public Test();

    descriptor: ()V

    flags: ACC_PUBLIC

    Code:

      stack=2, locals=4, args_size=1

         0: aload_0

         1: invokespecial #1                  // Method BaseClass."<init>":()V

         4: aload_0

         5: iconst_3

         6: invokestatic  #2                  // Method java/lang/Integer.valueOf:(I)Ljava/lang/Integer;

         9: putfield      #3        //成员变量赋值    // Field i:Ljava/lang/Integer;

         //第一个{}代码块

        12: iconst_1

        13: istore_1     // int a=1

        14: iconst_2

        15: istore_2     // int b=2

        16: iload_1

        17: iload_2

        18: iadd         

        19: istore_3     // int c=a+b

         //第二个{}代码块

        20: iconst_3

        21: istore_1     // int d=3

        22: iconst_4

        23: istore_2     // int e=4

        24: iload_2

        25: iload_1

        26: isub         

        27: istore_3     // int f=e-d

        28: bipush        8

        30: istore_1      //short s=8;

        31: return

第一{}中的a的slot是1，第二个{}的d的slot也是1，那不是存在复盖了，这样下次引用不就是错的吗？

由此可见，java类有多个{}块是，编译器并不是简单地将其合并到构造函数，而是将其做为一个独立的普通的java方法，因此多个{}块不受影响

2，static{}块

    仅能访问java类的静态成员变量

    static{}块所定的局部变量不能被 外部访问

clinit方法：

不具有继承性，因为它是在类加载过程中被调用，而父类与子类是分别加载的，当父类加载完之后，父类中的static成员变量初始化，static{}代码块已经执行完成，所以没有必要在子类加载时再执行一次

同样试验多个static{}块

public class Test extends BaseClass {

     private Integer i=3;

     private static int a=90;

     static {

     int a=1;

    int b=2;

    int c=a+b;

     }

     static {

    int d=3;

    int e=4;

    int f=e-d;

}

     public Test(){

      short s=8;

      }

     public void add(int a,int b){

     Test test=this;

     int z=a+b;

     int x=3;

}

     public static void main(String[] args){

     Test test=new Test();

     test.add(2,3);

    }

}

static {};

    descriptor: ()V

    flags: ACC_STATIC

    Code:

      stack=2, locals=3, args_size=0

         0: bipush        90

         2: putstatic     #7                  // Field a:I

          5: iconst_1

         6: istore_0

         7: iconst_2

         8: istore_1

         9: iload_0

        10: iload_1

        11: iadd

        12: istore_2

        13: iconst_3

        14: istore_0

        15: iconst_4

        16: istore_1

        17: iload_1

        18: iload_0

        19: isub

        20: istore_2

        21: return

}

vikenpeng
关注
  • 1
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
详谈jvm--Java中init和clinit的区别
08-29
下面小编就为大家带来一篇详谈jvm--Java中init和clinit的区别。小编觉得挺不错的，现在就分享给大家，也给大家做个参考。一起跟随小编过来看看吧
Java字节码＜init＞＜clinit＞的区别
qq_45877931的博客
12-20 373
<init>是实例化类时调用的方法，对非静态变量解析初始化，而<clinit>是类在初始化时调用的方法，是class类构造器对静态变量，静态代码块进行初始化，子类的<init>方法中会先对父类<init>方法的调用，并且clinit优先于init，下面我们拿代码测试一下： public class Test02 { public int age = 18; public String name = "John"; public Tes
clinit与init学习
qq_49150614的博客
07-28 414
clinit方法是类构造器方法，只对类方法(static域和static代码块)进行初始化，clinit方法是在加载->链接->初始化的初始化阶段进行的。并且子类的init方法会首先调用父类的init方法（即在constructor中首先调用super）。总结clinit方法的的执行时间一定早于init，因为clinit方法是在类初始化过程中执行的，而init方法是在对象实例化时执行的。父类变量初始化(初始化非静态成员变量（赋予默认值）)父类变量初始化(这里的初始化，就是赋予默认值)父类静态语句块初始化。.
java中init,Java中init方法和clinit方法
weixin_39759270的博客
03-14 1317
init方法：.Java文件在编译后会在字节码文件中生成init方法，该方法被称之为实例构造器。init方法是在对象实例化时执行的。该方法中的操作及其顺序为1.父类变量初始化 2.父类语句块 3.父类构造函数 4.子类变量初始化 5.子类语句块 6.子类构造函数clinit方法：.java文件在编译后会在字节码文件中生成clinit方法，该方法被称之为类构造器。该方法中的操作及其顺序为：1...
jvm复习： 类中的非静态成员变量的初始化在字节码层面是在构造方法＜init＞中完成的
amadeus_liu2的博客
04-01 54
jvm
<init>()方法
孤落
10-22 5342
()方法，是虚拟机自己调用的，不在我们的程序中显性表示。       那么()的作用是什么？在什么时候被调用？ 实际上，JVM为每一个类的每一个构造方法都创建一个(）方法，用于初始化实例变量。 我们用一个例子来进行分析： public class Test{ private String name; private int age; public Test(){ } pu
Spring Boot 集成 MinIO（分布式对象存储系统）
09-27
在手写MinIO 工具类的过程中会摘取整体框架中的核心逻辑，简化代码实现过程，保留核心功能，例如：IOC、AOP、Bean生命周期、上下文、作用域、资源处理等内容实现。 适合人群：具备一定编程基础，工作1-3年的研发人员...
java-client：用于编写Appium测试的Java语言绑定，符合Mobile JSON Wire＆W3C Webdriver Protocol
02-03
Java客户端 这是用于编写Appium测试的Java语言绑定，符合 功能和其他有趣的信息 ... < id>jitpack.io</ id> < url>https://jitpack.io</ url> </ repository> </ repositories> 添加依赖项： < depe
apple越狱备份数据
12-13
at com.semaphore.jna.md.MDLibrary.<clinit>(MDLibrary.java:39) at com.semaphore.jna.idevice.win.WinDeviceLibrary.addNotificationHandler(WinDeviceLibrary.java:61) at ...
Java验证码Cage.zip
07-19
Cage 是一个 Java 实现的验证码图片生成库，快速、小型和简单。 示例代码： public class QuickStart { ... <artifactId>cage</artifactId>  <version>1.0</version> </dependency> 标签：Cage
java中init方法是怎样生成的？
热门推荐
wobushixiaobailian的博客
11-14 2万+
一个类可以有多个方法，但只能有一个方法。 需要注意的是方法值初始化本类中的实例变量。 类变量的三种初始化方法 <init>的是怎样生成的 遇到new时;
类的＜cinit＞()V方法、＜init＞()V、与方法调用
Promise_J_Z
11-29 1006
<cinit>()V方法 一个类在加载的时候，编译器会按从上至下的顺序，收集所有 static 静态代码块和静态成员赋值的代码，合并为一个特殊的方法 <cinit>()V ：并调用。 对应字节码 <init>()V 编译器会按从上至下的顺序，收集所有 {} 代码块和成员变量赋值的代码，形成新的构造方法，但原始构 造方法内的代码总是在最后 private String a = "s1"; { b = 20; .
clinit和init
lopeasd
07-26 530
在编译生成class文件时，会自动产生两个方法，一个是类的初始化方法<clinit>, 另一个是实例的初始化方法<init> <clinit>方法的执行时期 类初始化阶段(该方法只能被jvm调用, 专门承担类变量的初始化工作) 在jvm第一次加载class文件时调用，包括静态变量初始化语句和静态块的执行 类的初始化时机: 1.主动引用 遇到 n...
静态代码块和静态变量的初始化（＜clinit＞()方法执行）
weixin_44250483的博客
11-15 1371
类加载过程 类加载过程中的“类加载”是一个整体的词，主要包括以下三个阶段： 加载：通过类加载器经Class文件加载进内存，提取出类的元数据存储在方法区当中，在堆当中生成Class对象。 连接：将Java类的二进制代码合并到JVM的运行状态之中的过程。 验证：确保类的信息符合JVM规范，没有危害安全的问题 准备：为静态变量分配内存，并初始化默认值（方法区） 解析：将虚拟机常量池中符号引用转为直接引用 初始化：执行类构造器<clinit>()方法。 类构造器方...
python之类与对象（3）
weixin_30687811的博客
12-04 121
4.类的初始化函数__init__(): 本章参考：https://blog.csdn.net/hellocsz/article/details/82795514 原作者：hellocsz 总结一下， 加上__init__()方法后，类才可以实例化，不加类就是个空壳，相当于一个方法集合 学习Python的类，一直不太理解为什么一定要定义init()方法，现在简要谈一下...
类加载之 <clinit>() 和 <init>()
weixin_30698527的博客
07-09 168
前序文章：深入理解Java类加载 <clinit>() 与 <init>() 区别 一、<clinit>() Java 类加载的初始化过程中，编译器按语句在源文件中出现的顺序，依次自动收集类中的所有类变量的赋值动作和静态代码块中的语句合并产生 <clinit>() 方法。 如果类中没有静态语句和静态代码块，那可以不生成()` 方法。 并且...
类加载机制详解
yygr的博客
03-17 369
类加载机制_爱吃袜子的二哈的博客-CSDN博客 一个Java文件从编码完成到最终执行，一般主要包括两个过程 编译 运行 编译，即把我们写好的java文件，通过javac命令编译成字节码，也就是我们常说的.class文件。 运行，则是把编译生成的.class文件交给Java虚拟机(JVM)执行。 而我们所说的类加载过程即是指JVM虚拟机把.class文件中类信息加载进内存，并进行解析生成对应的class对象的过程。 例子，JVM在执行某段代码时，遇到了class A， 然而此时内存中并没有c
《JVM系列》深入浅出类加载机制中＜init＞和＜Clinit＞的区别【一篇即可搞懂初始化机制】
Kevinnsm的博客
12-01 1217
文章目录前言：init和Clinit怎么产生的？1.init方法1.1.init方法什么时候被调用？用来做什么？1.2.那么实例变量赋值操作、非静态代码块、构造器这三者，哪一个会先执行呢？1.3.那么既然赋值操作和非静态代码块优先级是相同的，那么看下面代码分析能不能这样操作？1.4.分析如下代码，看init方法字节码指令1.5.分析如下代码，看你搞懂init方法没呢~！2.Clinit方法2.1.你会不会有个疑问，为什么需要Clinit方法？2.2.Clinit方法什么时候被调用？2.3.Clinit方法有
类构造器＜clinit＞()，实例构造器＜init＞()
张紫娃的博客
09-19 1309
clinit>()<init>()和<clinit>()这两个构造器的产生实际上是一种代码收敛的过程编译器会把1、（对于实例构造器而言是“{}”块，对于类构造器而言是“static{}”块2、（对于实例构造器而言是实例变量，对于类构造器而言是类变量3、仅仅是实例构造器<clinit>()方法中无须调用父类的<clinit>()方法，Java虚拟机会自动保证父类构造器的正确执行）等操作收敛到<init>()和<clinit>()方法之中。并且保证。
java 类构造器方法与<clinit>有什么关系
最新发布
05-15
Java类构造器方法和`<clinit>`都是Java类的初始化方法，但是它们的作用和触发时机不同。 构造器方法是用来初始化类的实例对象的，它会在每次创建实例对象时被调用，用于初始化实例的成员变量和执行一些操作。 `<clinit>`是类的静态初始化方法，它会在类被加载时自动调用，用于初始化类的静态成员变量和执行静态代码块。`<clinit>`方法是由编译器自动生成的，它会保证在类被使用之前被调用，即使没有显式调用它。 在Java类的初始化过程中，`<clinit>`方法会优先于构造器方法被调用。并且在类的初始化过程中，`<clinit>`方法只会被调用一次，用于初始化类的静态成员变量和执行静态代码块。 因此，构造器方法和`<clinit>`方法虽然都是Java类的初始化方法，但是它们的作用和触发时机是不同的。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值