以下程序执行的结果是_

ridikuius

答案C

初始化过程：

1. 初始化父类中的静态成员变量和静态代码块 ；

2. 初始化子类中的静态成员变量和静态代码块 ；

3.初始化父类的普通成员变量和代码块，再执行父类的构造方法；

4.初始化子类的普通成员变量和代码块，再执行子类的构造方法；

（1）初始化父类的普通成员变量和代码块，执行 Y y=new Y(); 输出Y

（2）再执行父类的构造方法；输出X

（3） 初始化子类的普通成员变量和代码块，执行 Y y=new Y(); 输出Y

（4）再执行子类的构造方法；输出Z

所以输出YXYZ

编辑于 2015-10-12 10:57:43 回复(32)

夜的哀伤

静态变量默认值 -> （静态变量给定值 -> 静态块或者静态块 -> 静态变量给定值） -> 成员变量默认值 -> （成员变量给定值 -> 构造块或者构造块 -> 成员变量给定值） -> 构造方法

发表于 2021-12-24 00:33:44 回复(0)

邓帅

1. 初始化父类中的静态成员变量和静态代码块 ；

2. 初始化子类中的静态成员变量和静态代码块 ；

3.初始化父类的普通成员变量和代码块，再执行父类的构造方法；

4.初始化子类的普通成员变量和代码块，再执行子类的构造方法；

发表于 2021-10-23 16:32:50 回复(0)

牛客425369244号

初始化过程， 1先初始化父类静态模块， 2再到子类静态模块， 3再到父类普通， 4再到父类构造， 5再到子类普通 6再到子类构造

编辑于 2020-09-14 06:34:09 回复(0)

ming_ming

初始化过程：

1. 初始化父类中的静态成员变量和静态代码块；

2. 初始化子类中的静态成员变量和静态代码块；

3.初始化父类的普通成员变量和代码块，再执行父类的构造方法；

4.初始化子类的普通成员变量和代码块，再执行子类的构造方法；

（1）初始化父类的普通成员变量和代码块，执行 Y y=new Y(); 输出Y

（2）再执行父类的构造方法；输出X

（3）初始化子类的普通成员变量和代码块，执行 Y y=new Y(); 输出Y

（4）再执行子类的构造方法；输出Z

所以输出YXYZ

发表于 2016-07-27 12:37:55 回复(0)

菜小豆

1.父类静态代码块（ java虚拟机加载类时，就会执行该块代码，故只执行一次）

2 .子类静态代码块（ java虚拟机加载类时，就会执行该块代码，故只执行一次）

3. 父类属性对象初始化

4.父类普通代码块（每次new,每次执行 ）

5. 父类构造函数（每次new,每次执行）

6.子 类 属性对象初始化

7.子类普通代码块（每次new,每次执行 ）

8.子 类构造函数（每次new,每次执行）

发表于 2015-10-10 16:23:44 回复(1)

叶磊201905122010454

初始化步骤：

1.父类静态变量本题无

2.父类静态代码块本题无

3.子类静态变量本题无

4.子类静态代码块本题无

5.父类非静态变量输出“y”

6.父类非静态代码块本题无

7.父类构造函数输出“x”

8.子类非静态变量输出“y”

9.子类非静态代码块本题无

10.子类构造函数输出“z”

所以输出：yxyz

发表于 2019-06-05 16:39:33 回复(5)

风屿alter

 /* 
 涉及继承：
 a.初始化父类中的静态成员变量和静态代码块  
 b.初始化子类中的静态成员变量和静态代码块
 c.初始化父类的普通成员变量和构造代码块(按次序)，再执行父类的构造方法
 d.初始化子类的普通成员变量和构造代码块(按次序)，再执行子类的构造方法
 */
class X {
   {System.out.print("1");}
    
    Y y=new Y();
 
    public X(){
        System.out.print("X");
    }
    
    {System.out.print("2");}
}
class Y{
    public Y(){
        System.out.print("Y");
    }
}
public class Z extends X {
    {System.out.print("3");}
    Y y=new Y();
    public Z() {
        System.out.print("Z");
    }
    {System.out.print("4");}
    public static void main(String[] args) {
        new Z();
    }
}

result：1Y2X3Y4Z

编辑于 2015-12-28 16:22:55 回复(7)

佳人

1)初始化父类静态变量、静态代码块

2)初始化子类静态变量、静态代码块

3）初始化父类普通成员变量、代码块、执行父类构造方法

4）初始化子类成员变量、代码块、子类构造方法

发表于 2016-01-20 18:12:40 回复(0)

心静

Java中构造函数执行顺序的问题

1，先执行内部静态对象的构造函数，如果有多个按定义的先后顺序执行；而且静态类的构造函数只会被执行一次，只在其第一个对象创建时调用，即便是创建了同一个类的多个对象

2，再执行父类的构造函数（c++中如果有多个，可按照左右先后顺序执行）

3，再执行内部普通对象的构造函数

4，最后执行该类本身的构造函数

发表于 2015-10-10 15:51:08 回复(0)

牛客628457号

java程序运行过程：首先运行extends继承的类的方法，然后在顺序进行本类中的方法

发表于 2015-10-10 10:42:55 回复(0)

天射手座

通过eclipse的单步调试还原了程序执行顺序：
主要执行过程（行号）：17-18-14-2-7-8-9(输出Y)-3-4(输出X)-13-8-9(输出Y)-14-15(输出Z)
故输出连起来就是：YXYZ

编辑于 2019-01-06 23:27:36 回复(0)

催忆泪

主要是看JAVA程序的运行顺序,以及继承关系.

首先,从Test类的测试类开始运行.进入main函数.
main就只创建了一个Test类,
那么就跳到Test类,
注意这个Test类继承了X这个类,
所以应该先去运行继承下来的X类:
1. X类先创建一个Y类,Y类只有一个方法:输出字符Y
2. X类运行自己的方法
X() {
System.out.print("X");
} 输出字符X
完了才是运行这两句:
Y y = new Y();
输出字符Y
Test() {
System.out.print("Z");
}
输出字符Z
看看顺序,由于System.out.print方法的问题,这四个字符刚好连在一起,按顺序输出就是YXYZ

发表于 2019-09-05 17:26:43 回复(0)

Hepsilion2

@Wangle

初始化过程：

1. 初始化父类中的静态成员变量和静态代码块；

2. 初始化子类中的静态成员变量和静态代码块；

3.初始化父类的普通成员变量和普通代码块，再执行父类的构造方法；

4.初始化子类的普通成员变量和普通代码块，再执行子类的构造方法；

另外，静态代码块和静态成员变量，普通代码块和普通成员变量分别属于同一级别，按顺序加载

class X{
    public X(String str){
        System.out.println(str+" print X");
    }
}
class Father{
	static X x1=new X("Father Static Member");
	X x2=new X("Father common Member");
    public Father(){
        System.out.println("Father constructor");
    }
    {
    	System.out.println("Father common code block");
    }
    static{
    	System.out.println("Father static code block");
    }
}
public class Child extends Father{
	{
    	System.out.println("Child common code block");
    }
	static X x1=new X("Child Static Member");
	X x2=new X("Child common Member");
	public Child(){
		System.out.println("Child constructor");
	}
	
    public static void main(String args[]) {
    	new Child();
    }
    static{
    	System.out.println("Child static code block");
    }
}

运行结果

Father Static Member print X
Father static code block
Child Static Member print X
Child static code block
Father common Member print X
Father common code block
Father constructor
Child common code block
Child common Member print X
Child constructor

发表于 2016-11-27 10:52:15 回复(3)

Jemmy

初始化顺序：

3 个原则：

静态变量优先于非静态变量
父类优先于子类
成员变量按照定义顺序

具体细节：

父类静态变量，父类静态代码块
子类静态变量，子类静态代码块
父类非静态变量，父类非静态代码块，父类构造函数
子类非静态变量，子类非静态代码块，子类构造函数

发表于 2016-08-08 00:43:01 回复(0)

scanf_cin

创建子类对象的过程是先穿件父类对象，父类对象创建过程中需先初始化对象y，因此第一步输出y，第二步调用x的构造函数输出x，第三步回到子类z中，z中也存在一个y的初始化过程，因此要先调用y的构造函数，此时输出y，再调用z的构造函数输出z。因此答案是yxyz。选c

发表于 2015-10-10 19:11:28 回复(0)

哈哈哈哈嗝嗝

答案C 初始化过程： 1. 初始化父类中的静态成员变量和静态代码块； 2. 初始化子类中的静态成员变量和静态代码块； 3.初始化父类的普通成员变量和代码块，再执行父类的构造方法； 4.初始化子类的普通成员变量和代码块，再执行子类的构造方法；（1）初始化父类的普通成员变量和代码块，执行 Y y=new Y(); 输出Y （2）再执行父类的构造方法；输出X （3）初始化子类的普通成员变量和代码块，执行 Y y=new Y(); 输出Y （4）再执行子类的构造方法；输出Z 所以输出YXYZ

发表于 2017-06-17 10:44:05 回复(0)