首页 > 试题广场 >

代码执行的先后顺序为？

[单选题]
子类A继承父类B, A a = new A(); 则父类B构造函数、父类B静态代码块、父类B非静态代码块、子类A构造函数、子类A静态代码块、子类A非静态代码块 执行的先后顺序是？ 
  • 父类Ｂ静态代码块->父类Ｂ构造函数->子类Ａ静态代码块->父类Ｂ非静态代码块->子类Ａ构造函数->子类Ａ非静态代码块
  • 父类Ｂ静态代码块->父类Ｂ构造函数->父类Ｂ非静态代码块->子类Ａ静态代码块->子类Ａ构造函数->子类Ａ非静态代码块
  • 父类Ｂ静态代码块->子类Ａ静态代码块->父类Ｂ非静态代码块->父类Ｂ构造函数->子类Ａ非静态代码块->子类Ａ构造函数
  • 父类Ｂ构造函数->父类Ｂ静态代码块->父类Ｂ非静态代码块->子类Ａ静态代码块->子类Ａ构造函数->子类Ａ非静态代码块
添加回答
推荐
梁帅头像 梁帅
正确的执行顺序是:父类Ｂ静态代码块->子类Ａ静态代码块->父类Ｂ非静态代码块->父类Ｂ构造函数->子类Ａ非静态代码块->子类Ａ构造函数
也就是说非静态初始化块的执行顺序要在构造函数之前。 

class SuperClass{
	private static String STR = "Super Class Static Variable";
	static{
		System.out.println("Super Class Static Block:"+STR);
	}

	public SuperClass() {
		System.out.println("Super Class Constructor Method");
	}
	{
		System.out.println("Super Class Block");
	}

}
public class ObjectInit extends SuperClass{
	private static String STR = "Class Static Variable";
	static{
		System.out.println("Class Static Block:"+STR);
	}

	public ObjectInit() {
		System.out.println("Constructor Method");
	}
	{
		System.out.println("Class Block");
	}
	public static void main(String[] args) {
		@SuppressWarnings("unused")
		ObjectInit a =new ObjectInit();
	}
}
执行完之后可以看到顺序如下:
Super Class Static Block:Super Class Static Variable
Class Static Block:Class Static Variable
Super Class Block
Super Class Constructor Method
Class Block
Constructor Method
编辑于 2021-08-17 18:10:26 回复(10)
kmust_XiaQing头像 kmust_XiaQing
当实例化子类对象时，首先要加载父类的class文件进内存，静态代码块是随着类的创建而执行，所以父类静态代码块最先被执行，子类class文件再被加载，同理静态代码块被先执行；实例化子类对象要先调用父类的构造方法，而调用父类构造方法前会先执行父类的非静态代码块
发表于 2015-08-08 10:42:11 回复(22)
笨小孩ovo头像 笨小孩ovo
正确执行顺序： 
父类Ｂ静态代码块->子类Ａ静态代码块->父类Ｂ非静态代码块->父类Ｂ构造函数->子类Ａ非静态代码块->子类Ａ构造函数

发表于 2022-03-10 10:12:26 回复(0)
七。小H头像 七。小H
会先执行静态代码块，因为静态代码块是类级别的，是在创建对象之前就执行的。因为子类继承了父类，所以父类的静态代码块会先执行，接着执行子类的静态代码块。

     因为构造函数可能要给动态代码块的一些成员变量赋值，所以必须在这之前先执行动态代码块，要不然构造函数会出现相关的成员属性无定义。所以会先执行动态代码块，在执行构造函数。一般先按父类的执行，再按子类的执行。

发表于 2015-10-08 21:30:52 回复(2)
Captainljl头像 Captainljl
按照先后顺序：
1，静态先于非静态代码库执行（静态代码块随着类的加载而加载，初始化只执行一次）
2，父类先于子类
3，非静态代码块优于构造函数执行
发表于 2016-07-04 10:48:29 回复(1)
Koolboy头像 Koolboy
解题要点：
1、静态代码块、静态变量是和类相关的，会随着类的加载而执行，且在类的生命周期内只执行一次；
2、非静态代码块、非静态变量是和对象相关的，每构造一个对象就会执行一次；
执行顺序：
执行父类的静态成员（变量和代码块，执行顺序根据编写的代码顺序执行）-->执行子类的静态成员（变量和代码块，执行顺序根据编写的代码顺序执行）-->执行父类的非静态成员（变量和代码块，执行顺序同上）-->执行父类的构造函数-->执行子类的非静态成员（变量和代码块，执行顺序同上）-->执行子类的构造函数
发表于 2016-10-14 15:03:24 回复(2)
“猿先生”头像 “猿先生”
类初始化顺序如下：
（1）父类静态成员变量 --->（2） 父类静态代码块 ---> （3）子类静态成员变量 ---> （4）子类静态代码块 ---> 
（5）父类实例变量 ---> （6）父类非静态代码块 ---> （7）父类构造方法 ---> （8）子类实例变量 ---> （9）子类非静态代码块 ---> （10）子类构造方法
       蓝色代表父类，红色代表子类，根据以上顺序对比选项，答案为 C
发表于 2019-02-24 11:37:42 回复(1)
没有辣条吃头像 没有辣条吃
父类优先，静态优先，构造最后。
发表于 2017-04-26 19:08:10 回复(1)
zhisheng_blog头像 zhisheng_blog
选C   父类Ｂ静态代码块->子类Ａ静态代码块->父类Ｂ非静态代码块->父类Ｂ构造函数->子类Ａ非静态代码块->子类Ａ构造函数
发表于 2016-01-08 10:06:48 回复(0)
wenhaiz头像 wenhaiz

静态初始化块在类加载时执行，而加载当前类时会先加载父类（如果父类没有被加载）。
因此会先执行父类静态初始化块，再执行子类静态初始化块。

一个类的非静态初始化块会比构造方法先执行，执行顺序是先父类，后子类。
所以接下来是父类的非静态初始化块，父类构造方法，子类的非静态初始化块，子类构造方法。

如果当前类和父类都以被加载，那么只会执行非静态初始化块和构造方法。

public class Parent {
    static {
        System.out.println("父类静态初始化块");
    }
    {
        System.out.println("父类非静态初始化块");
    }
    public Parent() {
        System.out.println("父类构造方法");
    }
    //方法与类名同名
    public int Parent() {
        return 0;
    }
    public static void main(String... args) {
        //第一次创建时类还没有被加载，会执行静态初始化块
        Child c = new Child();
        //第二次创建时类已经被加载，只执行非静态初始化块和   构造方法
        Child d = new Child();
    }
}
class Child extends Parent {
    public Child() {
        System.out.println("子类构造方法");
    }
    static {
        System.out.println("子类静态初始化块");
    }
    {
        System.out.println("子类非静态初始化块");
    }
}

上面代码输出结果为：

父类静态初始化块
子类静态初始化块
父类非静态初始化块
父类构造方法
子类非静态初始化块
子类构造方法

父类非静态初始化块
父类构造方法
子类非静态初始化块
子类构造方法

发表于 2017-09-11 18:16:22 回复(1)
墨白头像 墨白
C，首先确定先有父母，才有子女；然后明确在new一个实例前，JVM加载类时会执行静态代码块部分，最后要知道非静态代码块会被JVM自动整合在构造方法中执行，按照代码书写的先后顺序；(本题代码块写在构造方法后面？)
发表于 2015-02-05 19:52:52 回复(1)
_Harper头像 _Harper
由父及子 静态先行
发表于 2022-03-30 22:19:30 回复(0)
积极努力前进qwq头像 积极努力前进qwq
先执行      父类的静态代码块和静态变量
然后执行  子类的静态代码块和静态变量
然后执行  父类的成员变量和非静态代码块，然后构造方法
然后执行  子类的成员变量和非静态代码块，然后构造方法
发表于 2020-03-26 23:28:23 回复(0)
牛客-007头像 牛客-007
答案：B
父类的构造在子类之前，静态代码块的执行在构造函数之前，非静态代码块的执行在构造函数之后
因此执行顺序是：父类Ｂ静态代码块->父类Ｂ构造函数->父类Ｂ非静态代码块->子类Ａ静态代码块->子类Ａ构造函数->子类Ａ非静态代码块
发表于 2015-01-18 15:37:44 回复(3)
一点也不牛乜头像 一点也不牛乜
当实例化子类对象时，首先要加载父类的class文件进内存，静态代码块是随着类的创建而执行，所以父类静态代码块最先被执行，子类class文件再被加载，同理静态代码块被先执行；实例化子类对象要先调用父类的构造方法，而调用父类构造方法前会先执行父类的非静态代码块
发表于 2021-11-27 19:22:15 回复(0)
openmind.头像 openmind.
发表于 2021-07-09 21:02:52 回复(0)
咸鱼翻身粘锅头像 咸鱼翻身粘锅
1. 类中执行顺序的优先级为：父类静态代码块和父类静态变量>子类静态代码块和子类静态变量>main>父类普通代码块>父类构造方法>子类普通代码块>子类构造方法
2. 其中，父类静态代码块和父类静态变量之间的先后顺序由书写顺序决定。
发表于 2020-02-26 10:20:12 回复(0)
hjmin头像 hjmin
CSDN上看到的，挺全面。 当一个类从被JVM装载开始，各种代码的执行顺序大致如下： 被JVM装载->执行父类的相关代码->如果有静态初始化，先执行静态初始化，且只执行一次，以后即使有该类实例化，也不会再执行->如果有静态代码块，以与静态初始化一样的方式执行->如果有new语句带来的实例化，先为成员变量分配空间，并绑定参数列表，隐式或显式执行super()，即父类的构造方法，->执行非静态代码块-〉执行本类的构造函数-〉执行其他代码
发表于 2018-02-05 10:30:11 回复(0)
红茶知道头像 红茶知道
大家都知道结果了，我来说说原理，首先会加载父类，子类，然后也就执行了父类、子类的静态代码块，然后接着就是调用子类的构造函数了，那么大家很奇怪，那为什么答案是c，这是因为构造函数中有隐式的语句我们看不到，这是虚拟机在编译时加到构造函数中的，其中第一行是super（），调用父类空参数构造函数的意思，当然也可以自己指定调用父类哪个构造函数，自己写了虚拟机就不会帮我们加上super（）了，然后接着是调用本类构造代码块的语句，接着才是我们自己写的语句，所以程序执行后才会打印出c答案的结果。 总之记住在构造函数的最开头有隐式的语句，是jvm在编译时加上的，第一句是调用父类构造函数，第二句是调用本类构造代码块，接着才是自己写的语句。
发表于 2017-08-14 10:22:18 回复(0)
YoungJi头像 YoungJi
非静态代码块也可认为是构造代码块，在编译时会添加到所有构造函数中，并位于最前面。所以非静态代码块总是优先于构造函数执行。
发表于 2017-04-16 23:10:50 回复(0)
半纸流年头像 半纸流年
父类的构造方法在子类的构造方法之前执行，非静态的初始化方法在构造方法之前执行。静态方法最先执行。
父类的静态方法->子类的静态方法->父类的非静态初始化方法->父类的构造方法->子类的非静态初始化方法->子类的构造方法
发表于 2015-11-18 19:39:29 回复(1)
提交观点

问题信息

阿里巴巴 Java
上传者：小小
难度：
88条回答 18999浏览

热门推荐

相关试题

扫一扫，把题目装进口袋

求职之前，先上牛客

扫描二维码，进入QQ群

扫描二维码，关注牛客公众号