首页 > 试题广场 >

以下程序执行的结果是

[单选题]
以下程序执行的结果是： 
class X{
	Y y=new Y();
	public X(){
		System.out.print("X");
	}
}
class Y{
	public Y(){
		System.out.print("Y");
	}
}
public class Z extends X{
	Y y=new Y();
	public Z(){
		System.out.print("Z");
	}
	public static void main(String[] args) {
		new Z();
	}
}
  • ZYXX
  • ZYXY
  • YXYZ
  • XYZX
查看答案及解析
添加回答
ridikuius头像 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)
ming_ming头像 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头像 叶磊201905122010454
初始化步骤：
1.父类静态变量                      本题无
2.父类静态代码块                  本题无
3.子类静态变量                      本题无
4.子类静态代码块                  本题无
5.父类非静态变量                    输出“y”
6.父类非静态代码块                本题无
7.父类构造函数                        输出“x”
8.子类非静态变量                    输出“y”
9.子类非静态代码块                本题无
10.子类构造函数                      输出“z”
所以输出：yxyz






发表于 2019-06-05 16:39:33 回复(6)
风屿alter头像 风屿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)
心静头像 心静
1，  先执行内部静态对象的构造函数，如果有多个按定义的先后顺序执行；而且静态类的构造函数只会被执行一次，只在其第一个对象创建时调用，即便是创建了同一个类的多个对象

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

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

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

发表于 2015-10-10 15:51:08 回复(0)
牛客628457号头像 牛客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头像 Hepsilion2
初始化过程： 
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头像 Jemmy
初始化顺序：
3 个原则：
  1.     静态变量优先于非静态变量
  2.     父类优先于子类
  3.     成员变量按照定义顺序
具体细节：
  •     父类静态变量，父类静态代码块
  •     子类静态变量，子类静态代码块
  •     父类非静态变量，父类非静态代码块，父类构造函数
  •     子类非静态变量，子类非静态代码块，子类构造函数
发表于 2016-08-08 00:43:01 回复(0)
scanf_cin头像 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)
LirANRan_头像 LirANRan_
我的感觉是 当new一个类的时候 先运行其构造函数  但是编译出来的是 后运行， 是C选项 不太懂
发表于 2015-10-10 14:26:51 回复(1)
ljn1122头像 ljn1122
（1）Z 继承了 X 会先初始化 X类，X中输出:YX
（2）Y y=new Y();  输出Y
（3） 输出 :Z

所以结果=YXYZ

发表于 2022-03-31 17:56:13 回复(0)
嘻嘻作者哈哈头像 嘻嘻作者哈哈
  • 类中结构加载顺序：由父及子，静态先行。
  • 属性赋值顺序：
    • 默认初始化。
    • 显示初始化或代码块中初始化。
    • 构造器初始化。
  • 所以该题先调用父类，再调用子类。在类中先用new显示初始化，再调用构造器。
发表于 2022-02-24 23:01:34 回复(0)
牛客855297560号头像 牛客855297560号 
class X{                                      //2，父类无静态成员和代码块
    Y y=new Y();                                 //4，执行父类的普通成员变量和代码块，输出Y
    public X(){                                  //5，再执行父类的构造方法，输出X
        System.out.print("X");   
         }
}
class Y{    
     public Y(){
        System.out.print("Y");
    }
}
public class Z extends X{                             //3，子类也无静态成员变量和代码块
    Y y=new Y();                           //6，执行子类的普通成员变量和代码块，输出Y
    public Z(){                            //7,执行子类的构造方法，输出Z
        System.out.print("Z");
    }
    public static void main(String[] args) {
        new Z();                          //1，创建一个子类对象实例
    }
}

发表于 2022-02-19 00:36:53 回复(0)
宋佑廉头像 宋佑廉
初始化的过程
1初始化父类的静态成员变量和静态代码块
2初始化子类的静态成员变量和静态代码块
3初始化父类的普通成员变量和代码块,再执行父类的构造方法
4初始化子类的普通成员变量和代码块,再执行子类的构造方法
发表于 2018-10-30 14:54:23 回复(0)
猫丫头像 猫丫
初始化过程： 
1. 初始化父类中的静态成员变量和静态代码块 ； 
2. 初始化子类中的静态成员变量和静态代码块 ； 
3.初始化父类的普通成员变量和代码块，再执行父类的构造方法；
4.初始化子类的普通成员变量和代码块，再执行子类的构造方法； 
 
（1）初始化父类的普通成员变量和代码块，执行  Y y=new Y();  输出Y 
（2）再执行父类的构造方法；输出X
（3） 初始化子类的普通成员变量和代码块，执行  Y y=new     Y();  输出Y 
（4）再执行子类的构造方法；输出Z
 所以输出YXYZ
发表于 2016-06-12 18:07:43 回复(0)
提交观点

问题信息

Java
来自：网易笔试练习卷
难度：
123条回答 20218浏览

热门推荐

相关试题

扫一扫，把题目装进口袋

求职之前，先上牛客

扫描二维码，进入QQ群

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