Java父类与子类中静态代码块 实例代码块 静态变量 实例变量 构造函数执行顺序

最新推荐文章于 2022-09-06 15:54:10 发布
原创 最新推荐文章于 2022-09-06 15:54:10 发布 · 1.5k 阅读 · 2 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#Java #父类 #子类 #静态变量 #代码块

本文深入解析Java中类加载过程中静态代码块、实例代码块、静态变量及实例变量的执行顺序，通过具体示例代码和反编译结果进行验证。

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

实例化子类时，父类与子类中的静态代码块、实例代码块、静态变量、实例变量、构造函数的执行顺序是怎样的？


代码执行的优先级为：

firest：静态部分

second：实例化过程


详细顺序为：

1.父类静态代码块与父类静态变量赋值（取决于代码书写顺序）

2.子类静态代码块与子类静态变量赋值（取决于代码书写顺序）

3.父类实例变量赋值与父类代码块（取决于代码书写顺序）

4.父类构造函数

5.子类实例变量赋值与子类代码块（取决于代码书写顺序）

6.子类构造函数


在JVM加载完类以后，类在被使用的时候初始化，静态部分只在类初始化的时候执行一次。


测试代码：


class Father {

    Father() {
        LogUtil.log(System.currentTimeMillis() + " ------ 父类构造函数");
    }

    static {
        LogUtil.log(System.currentTimeMillis() + " ------ 父类静态代码块");
    }

    long x = getTime(" ------ 父类实例变量赋值");

    {
        long time = System.currentTimeMillis();
        LogUtil.log(time + " ------ 父类代码块");
    }

    static long y = getTime(" ------ 父类静态变量赋值");

    static long getTime(String who) {
        long time = System.currentTimeMillis();
        LogUtil.log(time + who);
        return time;
    }
}

class Child extends Father {

    Child() {
        LogUtil.log(System.currentTimeMillis() + " ------ 子类构造函数");
    }

    static long y = getTime(" ------ 子类静态变量赋值");

    static {
        LogUtil.log(System.currentTimeMillis() + " ------ 子类静态代码块");
    }

    {
        long time = System.currentTimeMillis();
        LogUtil.log(time + " ------ 子类代码块");
    }

    long x = getTime(" ------ 子类实例变量赋值");

    static long getTime(String who) {
        long time = System.currentTimeMillis();
        LogUtil.log(time + who);
        return time;
    }
}

调用代码：

new Thread(new Runnable() {
            @Override
            public void run() {
                new Child();
                LogUtil.log("分隔符 ------ 分隔符");
                new Child();
            }
        }).start();

执行结果： 

11-03 20:02:03.350 7533-7881/? E/AKADDEMO: 1478174523353 ------ 父类静态代码块
11-03 20:02:03.350 7533-7881/? E/AKADDEMO: 1478174523353 ------ 父类静态变量赋值
11-03 20:02:03.350 7533-7881/? E/AKADDEMO: 1478174523353 ------ 子类静态变量赋值
11-03 20:02:03.350 7533-7881/? E/AKADDEMO: 1478174523353 ------ 子类静态代码块
11-03 20:02:03.350 7533-7881/? E/AKADDEMO: 1478174523353 ------ 父类实例变量赋值
11-03 20:02:03.350 7533-7881/? E/AKADDEMO: 1478174523353 ------ 父类代码块
11-03 20:02:03.350 7533-7881/? E/AKADDEMO: 1478174523353 ------ 父类构造函数
11-03 20:02:03.350 7533-7881/? E/AKADDEMO: 1478174523353 ------ 子类代码块
11-03 20:02:03.350 7533-7881/? E/AKADDEMO: 1478174523353 ------ 子类实例变量赋值
11-03 20:02:03.350 7533-7881/? E/AKADDEMO: 1478174523353 ------ 子类构造函数
11-03 20:02:03.350 7533-7881/? E/AKADDEMO: 分隔符 ------ 分隔符
11-03 20:02:03.350 7533-7881/? E/AKADDEMO: 1478174523353 ------ 父类实例变量赋值
11-03 20:02:03.350 7533-7881/? E/AKADDEMO: 1478174523353 ------ 父类代码块
11-03 20:02:03.350 7533-7881/? E/AKADDEMO: 1478174523353 ------ 父类构造函数
11-03 20:02:03.350 7533-7881/? E/AKADDEMO: 1478174523354 ------ 子类代码块
11-03 20:02:03.350 7533-7881/? E/AKADDEMO: 1478174523354 ------ 子类实例变量赋值
11-03 20:02:03.350 7533-7881/? E/AKADDEMO: 1478174523354 ------ 子类构造函数

－－－－－－－－－－－－－2018.1.5－－－－－－－－－－－－－－－

我们通过反编译工具（IntelliJ IDEA或JD-JUI）反编译一下class文件看能发现什么有意思的东西

测试代码：

class Father {

    Father() {
        System.out.print(System.currentTimeMillis() + " ------ 父类构造函数" + '\n');
    }

    private static long a = getTime(" -----a 父类静态变量赋值" + '\n');
    private final static long b = getTime(" -----b 父类静态变量赋值" + '\n');

    static {
        System.out.print(System.currentTimeMillis() + " ------ 父类静态代码块" + '\n');
    }

    long aa = getTime(" ----aa 父类实例变量赋值" + '\n');

    {
        System.out.print(System.currentTimeMillis() + " ------ 父类代码块" + '\n');
    }

    long bb = getTime(" ----bb 父类实例变量赋值" + '\n');

    static long z = getTime(" -----z 父类静态变量赋值" + '\n');

    static long getTime(String who) {
        long time = System.currentTimeMillis();
        System.out.print(time + who);
        return time;
    }

    private static long c = getTime(" -----c 父类静态变量赋值" + '\n');
    private final static long d = getTime(" -----d 父类静态变量赋值" + '\n');
}
调用代码： 

public static void main(String[] args) {
        new Father();
    }
执行结果： 

1515134833612 -----a 父类静态变量赋值
1515134833614 -----b 父类静态变量赋值
1515134833614 ------ 父类静态代码块
1515134833614 -----z 父类静态变量赋值
1515134833614 -----c 父类静态变量赋值
1515134833614 -----d 父类静态变量赋值
1515134833614 ----aa 父类实例变量赋值
1515134833614 ------ 父类代码块
1515134833614 ----bb 父类实例变量赋值
1515134833614 ------ 父类构造函数
用 IntelliJ IDEA 打开上述代码编译之后的 Father.class ： 

//
// Source code recreated from a .class file by IntelliJ IDEA
// (powered by Fernflower decompiler)
//

package com.ak.torch.videoplayer.disassamble;

public class Father {
    private static long a = getTime(" -----a 父类静态变量赋值\n");
    private static final long b = getTime(" -----b 父类静态变量赋值\n");
    long aa = getTime(" ----aa 父类实例变量赋值\n");
    long bb;
    static long z;
    private static long c;
    private static final long d;

    Father() {
        System.out.print(System.currentTimeMillis() + " ------ 父类代码块" + '\n');
        this.bb = getTime(" ----bb 父类实例变量赋值\n");
        System.out.print(System.currentTimeMillis() + " ------ 父类构造函数" + '\n');
    }

    static long getTime(String var0) {
        long var1 = System.currentTimeMillis();
        System.out.print(var1 + var0);
        return var1;
    }

    static {
        System.out.print(System.currentTimeMillis() + " ------ 父类静态代码块" + '\n');
        z = getTime(" -----z 父类静态变量赋值\n");
        c = getTime(" -----c 父类静态变量赋值\n");
        d = getTime(" -----d 父类静态变量赋值\n");
    }
}
可以发现：

1、在 Father.java 中静态变量a、b的赋值操作写在了静态代码块的前面，静态变量z、c、d的赋值操作写在了静态代码块的后面，查看反编译之后的代码，可见静态变量z、c、d的赋值被写在了静态代码块中。

2、在 Father.java 中实例变量aa的赋值操作写在了实例代码块的前面，实例变量bb的赋值操作写在了实例代码块的后面，查看反编译之后的代码，可见代码块中的操作和实例变量b的赋值都被写在了构造函数中。


下面分情况删除一些代码，我们看一下反编译之后的不同

情况一：删掉静态代码块，此时的 Father.java 代码：

class Father {

    Father() {
        System.out.print(System.currentTimeMillis() + " ------ 父类构造函数" + '\n');
    }

    private static long a = getTime(" -----a 父类静态变量赋值" + '\n');
    private final static long b = getTime(" -----b 父类静态变量赋值" + '\n');

    long aa = getTime(" ----aa 父类实例变量赋值" + '\n');

    {
        System.out.print(System.currentTimeMillis() + " ------ 父类代码块" + '\n');
    }

    long bb = getTime(" ----bb 父类实例变量赋值" + '\n');

    static long z = getTime(" -----z 父类静态变量赋值" + '\n');

    static long getTime(String who) {
        long time = System.currentTimeMillis();
        System.out.print(time + who);
        return time;
    }

    private static long c = getTime(" -----c 父类静态变量赋值" + '\n');
    private final static long d = getTime(" -----d 父类静态变量赋值" + '\n');
}
用 IntelliJ IDEA 打开上述代码编译之后的 Father.class ： 

//
// Source code recreated from a .class file by IntelliJ IDEA
// (powered by Fernflower decompiler)
//

package com.ak.torch.videoplayer.disassamble;

public class Father {
    private static long a = getTime(" -----a 父类静态变量赋值\n");
    private static final long b = getTime(" -----b 父类静态变量赋值\n");
    long aa = getTime(" ----aa 父类实例变量赋值\n");
    long bb;
    static long z = getTime(" -----z 父类静态变量赋值\n");
    private static long c = getTime(" -----c 父类静态变量赋值\n");
    private static final long d = getTime(" -----d 父类静态变量赋值\n");

    Father() {
        System.out.print(System.currentTimeMillis() + " ------ 父类代码块" + '\n');
        this.bb = getTime(" ----bb 父类实例变量赋值\n");
        System.out.print(System.currentTimeMillis() + " ------ 父类构造函数" + '\n');
    }

    static long getTime(String var0) {
        long var1 = System.currentTimeMillis();
        System.out.print(var1 + var0);
        return var1;
    }
}
可以发现：

任何一个静态变量的赋值都没有被写在静态代码块中


情况二：删掉实例代码块，此时的 Father.java 代码：

class Father {

    Father() {
        System.out.print(System.currentTimeMillis() + " ------ 父类构造函数" + '\n');
    }

    private static long a = getTime(" -----a 父类静态变量赋值" + '\n');
    private final static long b = getTime(" -----b 父类静态变量赋值" + '\n');

    static {
        System.out.print(System.currentTimeMillis() + " ------ 父类静态代码块" + '\n');
    }

    long aa = getTime(" ----aa 父类实例变量赋值" + '\n');

    long bb = getTime(" ----bb 父类实例变量赋值" + '\n');

    static long z = getTime(" -----z 父类静态变量赋值" + '\n');

    static long getTime(String who) {
        long time = System.currentTimeMillis();
        System.out.print(time + who);
        return time;
    }

    private static long c = getTime(" -----c 父类静态变量赋值" + '\n');
    private final static long d = getTime(" -----d 父类静态变量赋值" + '\n');
}
用 IntelliJ IDEA 打开上述代码编译之后的 Father.class ： 

//
// Source code recreated from a .class file by IntelliJ IDEA
// (powered by Fernflower decompiler)
//

package com.ak.torch.videoplayer.disassamble;

public class Father {
    private static long a = getTime(" -----a 父类静态变量赋值\n");
    private static final long b = getTime(" -----b 父类静态变量赋值\n");
    long aa = getTime(" ----aa 父类实例变量赋值\n");
    long bb = getTime(" ----bb 父类实例变量赋值\n");
    static long z;
    private static long c;
    private static final long d;

    Father() {
        System.out.print(System.currentTimeMillis() + " ------ 父类构造函数" + '\n');
    }

    static long getTime(String var0) {
        long var1 = System.currentTimeMillis();
        System.out.print(var1 + var0);
        return var1;
    }

    static {
        System.out.print(System.currentTimeMillis() + " ------ 父类静态代码块" + '\n');
        z = getTime(" -----z 父类静态变量赋值\n");
        c = getTime(" -----c 父类静态变量赋值\n");
        d = getTime(" -----d 父类静态变量赋值\n");
    }
}

可以发现：

任何一个实例变量的赋值都没有被写在构造函数中


情况三：删掉静态变量，此时的 Father.java 代码：

class Father {

    Father() {
        System.out.print(System.currentTimeMillis() + " ------ 父类构造函数" + '\n');
    }

    static {
        System.out.print(System.currentTimeMillis() + " ------ 父类静态代码块" + '\n');
    }

    long aa = getTime(" ----aa 父类实例变量赋值" + '\n');

    {
        System.out.print(System.currentTimeMillis() + " ------ 父类代码块" + '\n');
    }

    long bb = getTime(" ----bb 父类实例变量赋值" + '\n');

    static long getTime(String who) {
        long time = System.currentTimeMillis();
        System.out.print(time + who);
        return time;
    }
}
用 IntelliJ IDEA 打开上述代码编译之后的 Father.class ： 

//
// Source code recreated from a .class file by IntelliJ IDEA
// (powered by Fernflower decompiler)
//

package com.ak.torch.videoplayer.disassamble;

public class Father {
    long aa = getTime(" ----aa 父类实例变量赋值\n");
    long bb;

    Father() {
        System.out.print(System.currentTimeMillis() + " ------ 父类代码块" + '\n');
        this.bb = getTime(" ----bb 父类实例变量赋值\n");
        System.out.print(System.currentTimeMillis() + " ------ 父类构造函数" + '\n');
    }

    static long getTime(String var0) {
        long var1 = System.currentTimeMillis();
        System.out.print(var1 + var0);
        return var1;
    }

    static {
        System.out.print(System.currentTimeMillis() + " ------ 父类静态代码块" + '\n');
    }
}


情况四：删掉实例变量，此时的 Father.java 代码：

class Father {

    Father() {
        System.out.print(System.currentTimeMillis() + " ------ 父类构造函数" + '\n');
    }

    private static long a = getTime(" -----a 父类静态变量赋值" + '\n');
    private final static long b = getTime(" -----b 父类静态变量赋值" + '\n');

    static {
        System.out.print(System.currentTimeMillis() + " ------ 父类静态代码块" + '\n');
    }

    {
        System.out.print(System.currentTimeMillis() + " ------ 父类代码块" + '\n');
    }

    static long z = getTime(" -----z 父类静态变量赋值" + '\n');

    static long getTime(String who) {
        long time = System.currentTimeMillis();
        System.out.print(time + who);
        return time;
    }

    private static long c = getTime(" -----c 父类静态变量赋值" + '\n');
    private final static long d = getTime(" -----d 父类静态变量赋值" + '\n');
}

用 IntelliJ IDEA 打开上述代码编译之后的 Father.class ：

//
// Source code recreated from a .class file by IntelliJ IDEA
// (powered by Fernflower decompiler)
//

package com.ak.torch.videoplayer.disassamble;

public class Father {
    private static long a = getTime(" -----a 父类静态变量赋值\n");
    private static final long b = getTime(" -----b 父类静态变量赋值\n");
    static long z;
    private static long c;
    private static final long d;

    Father() {
        System.out.print(System.currentTimeMillis() + " ------ 父类代码块" + '\n');
        System.out.print(System.currentTimeMillis() + " ------ 父类构造函数" + '\n');
    }

    static long getTime(String var0) {
        long var1 = System.currentTimeMillis();
        System.out.print(var1 + var0);
        return var1;
    }

    static {
        System.out.print(System.currentTimeMillis() + " ------ 父类静态代码块" + '\n');
        z = getTime(" -----z 父类静态变量赋值\n");
        c = getTime(" -----c 父类静态变量赋值\n");
        d = getTime(" -----d 父类静态变量赋值\n");
    }
}

总结一下：


一、静态代码块 与 静态变量赋值 在反编译成的代码中的位置

1、如果存在静态代码块，并且有静态变量的赋值写在了静态代码块的下面，那么这样的静态变量最终的赋值操作会被写在静态代码块中

2、如果存在多个静态代码块，最终会合并为一个

二、实例变量赋值 与 实例代码块 在反编译成的代码中的位置

1、如果存在实例代码块，并且有实例变量的赋值写在了实例代码块的下面，那么实例代码块中的操作和这样的实例变量最终的赋值操作会被写在构造函数中

2、实例代码块中的操作都会被写在构造函数中

3、如果存在多个实例代码块，都会被写在构造函数中


了解了变量赋值与代码块的执行顺序，就能从代码执行的角度解释有时候在代码块中使用变量时为什么会提示“非法前向引用(illegal forward reference)”


反编译工具 IntelliJ IDEA 的BUG

根据 静态代码块 与 静态变量赋值 的执行顺序取决于代码书写顺序这一原则，测试Father.java

class Father {

    static {
        bb = getTime(" ----bb 父类实例变量" + '\n');
    }

    static long aa = getTime(" ----aa 父类实例变量" + '\n');
    static long bb;

    static long getTime(String who) {
        long time = System.currentTimeMillis();
        System.out.print(time + who);
        return time;
    }
}
执行结果： 

1515149709262 ----bb 父类实例变量
1515149709262 ----aa 父类实例变量
用 IntelliJ IDEA 打开上述代码编译之后的 Father.class

//
// Source code recreated from a .class file by IntelliJ IDEA
// (powered by Fernflower decompiler)
//

package com.ak.torch.videoplayer.disassamble;

public class Father {
    static long aa = getTime(" ----aa 父类实例变量\n");
    static long bb = getTime(" ----bb 父类实例变量\n");

    public Father() {
    }

    static long getTime(String var0) {
        long var1 = System.currentTimeMillis();
        System.out.print(var1 + var0);
        return var1;
    }
}
将此反编译之后的代码重新搞一个java文件，然后编译运行： 

1515151279918 ----aa 父类实例变量
1515151279919 ----bb 父类实例变量

可见由IntelliJ IDEA反编译出的代码的执行顺序已经不是原来类该有的顺序了，IntelliJ IDEA反编译处理的 实例代码块 与 实例变量的执行顺序也有类似问题。

经过测试，用 JD-JUI 反编译也会有上述的问题，但是兼容性比 IntelliJ IDEA 好一些。

所以，这两款反编译工具反编译出来的代码并不能保证跟原来类的逻辑完全一致。

使用javap命令可以获取类初始化时代码的正确执行顺序。

【类的实例化顺序，比如父类静态数据，构造函数，字段，子类静态数据，构造函数，字 段，当new的时候，他们的执行顺序】
学无止境
03-06 593
【类的实例化顺序，比如父类静态数据，构造函数，字段，子类静态数据，构造函数，字 段，当new的时候，他们的执行顺序】
子类静态属性、子类属性赋值、子类构造函数、子类构造代码块、子类静态代码块、父类静态属性、父类构造函数、父类构造代码块、父类静态代码块执行顺序
qq_42102428的博客
06-12 520
先看父类构造方法、子类构造方法、子类属性赋值 class Father { public Father() { System.out.println("父类构造方法"); show(); } public void show() { System.out.println("父类show"); } } class Son extends Father { int num =...
Java父类与子类中静态代码块 实例代码块 静态变量 实例变量 构造函数执行顺序...
weixin_34238633的博客
03-27 175
实例化子类时，父类与子类中的静态代码块、实例代码块、静态变量、实例变量、构造函数的执行顺序是怎样的？ 代码执行的优先级为： firest：静态部分 second：实例化过程 详细顺序为： 1.父类静态代码块与父类静态变量（取决于代码书写顺序） 2.子类静态代码块与子类静态变量（取决于代码书写顺序） 3.父类实例变量与父类代码块（取决于代码书写顺序） 4.父类构造函数 5.子类实例变量与父类...
子类，父类静态代码块，构造代码块，以及构造函数执行顺序
qq_36414747的博客
12-20 1144
父类： package com.Test; public class StaticExtends { //静态代码块     static{         System.out.println("父类静态代码块");         }     //构造代码块     {         System.out.println("父类构造代码块");     }     
几个问题（--------）父子类静态变量、静态代码块、非静态代码块、构造函数
beidou321的专栏
03-13 1671
父类和子类静态代码块、代码块、构造方法、实例方法执行顺序
m0_46378271的博客
09-06 1515
父类和子类静态代码块、代码块、构造方法、实例方法执行顺序
Java基础知识-父子类、代码块以及静态代码块
踏 浪的博客
07-08 1161
目录 1、第一个例子 2、第二个例子 3、第三个例子 4、第四个例子 5、第五个例子 6、第六个例子 1、第一个例子 父类 @Data public class Person { private String id; private String name; public Person() { System.out.println("执行父类构造方法。。。"); } } 子类 @Data public class Studen
java 代码块与静态代码块加载顺序
08-29
4. 子类实例代码块 在上面的实例代码中，我们可以看到 `User` 类的加载顺序按照以下顺序执行： 1. 首先执行静态代码块 `static { ... }`，打印出 "调用userSay静态方法" 和 "进入静态构造代码块"。 2. 其次执行...
java中静态代码块与构造方法的执行顺序判断
08-28
在Java编程语言中，了解静态...通过上述分析，我们可以清楚地理解Java中静态代码块与构造方法的执行顺序，这对于编写高效且可靠的代码至关重要。在实际编程中，了解这些基础知识有助于避免潜在的错误并优化代码结构。
构造函数与静态块的执行顺序
07-31
在探讨继承中子类与父类构造函数及静态块的执行顺序时，我们首先需要理解构造函数和静态块的基本概念及其在Java中的作用。构造函数主要用于初始化对象的状态，而静态块则是在类加载到内存中时执行的一段代码，通常...
简单了解java中静态初始化块的执行顺序
08-25
在Java中，静态初始化块的执行顺序非常重要，因为它会影响类的静态变量和静态方法的初始化。在实际开发中，了解静态初始化块的执行顺序非常重要，否则可能会导致类的静态变量和静态方法不能正确地初始化。 下面是一...
java 中父子类的静态代码块、代码块、构造方法的加载执行顺序
一颗小白羊
05-12 815
文章目录1 新建两个父子类2 新建测试类2.1 只加载父类时2.2 只加载子类时2.3 创建父类的实例时2. 4 创建子类的实例时 1 新建两个父子类 Father.java package t1; public class Father { { System.out.println("父类的代码块"); } static{ System.out.println("父类的静态代码块"); } public Father() { System.out.println("父类的
java 父类子类的构造方法，静态代码块，普通代码块的调用顺序
weixin_41909817的博客
12-20 407
class Person{ public Person() { System.out.println("1.父类构造方法"); } { System.out.println("3.父类普通代码块"); } static{ System.out.println("2.父类静态代码块"); } } cl...
java-静态代码块-父子类执行顺序
王洪洪的博客
04-19 152
父类-静态代码块 子类-静态代码块 子类-main函数 父类-非静态代码 父类-构造函数 子类-非静态代码 子类-构造函数 package test; public class FatherTest { static { System.out.println("父类-静态代码块"); } public FatherTest() { ...
父类和子类静态代码块、非静态代码块、构造函数（方法）执行的先后顺序问题
datoubangzhu的博客
09-10 2455
父类和子类静态代码块、非静态代码块、构造函数（方法）执行的先后顺序问题。
父子类 静态代码块、代码块、构造方法的执行顺序 父类静态代码块-〉子类静态代码块-〉父类代码块-〉父类构造方法-〉子类代码块-〉子类构造方法
AmbroseLe
12-24 412
顺序是：父类静态代码块-〉子类静态代码块-〉父类代码块-〉父类构造方法-〉子类代码块-〉子类构造方法 父类 public class Fatcher { static { System.out.println("fatcher_static"); } { System.out.println("fatcher_daimakuai");...
子类继承父类的实例方法与静态方法测试
wangsai_blog
09-11 698
子类继承父类的实例方法与静态方法测试 子类 结果 子类继承父类的实例方法同时也继承父类静态方法 在子类中测试： 1. 父类类名调用父类静态方法 正确 2.父类实例调用父类的静态方法 正确 3.子类类名调用超类的静态方法 正确 4.子类实例调用超累的静态方法 正确 5.子类类名调用本类的静态方法 正确 6.子类实例调用本类的静态方法 正确 7.子类...
Java中父类与子类的普通代码块，构造代码块，静态代码块 初始化
three__stones的博客
03-22 2087
//示例代码： public class HelloB extends HelloA{ public HelloB(){ System.out.println("子类构造方法"); } { System.out.println("子类构造代码块"); } static{ System.out.println("子类静态块"); } public st
子类父类-静态语句块-构造语句块-构造函数-执行顺序
qq824387335的博客
07-11 453
1、【代码1】考查静态语句块、构造语句块（就是只有大括号的那块）以及构造函数的执行顺序 2、对象的初始化顺序： （1）类加载之后，按从上到下（从父类到子类）执行被static修饰的语句； （2）当static语句执行完之后,再执行main方法； （3）如果有语句new了自身的对象，将从上到下执行构造代码块、构造器（两者可以说绑定在一起）。 3、其他方法如notRunMe()是不会被执
java 父类由子类new 执行父类中的方法，构造器及方法执行顺序
最新发布
07-29
- [^2]: 执行顺序：父类静态代码块 -> 子类静态代码块 -> 父类构造代码块 -> 父类构造方法 -> 子类构造代码块 -> 子类构造方法。 - [^3]: 子类初始化时调用父类构造方法，通常有隐式的super()调用父类无参数构造方法...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值