首页 > 试题广场 >

以下程序执行的结果是

[单选题]
以下程序执行的结果是： 
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 回复(31)
夜的哀伤头像 夜的哀伤
  • 静态变量默认值 -> （静态变量给定值 -> 静态块或者静态块 -> 静态变量给定值） -> 成员变量默认值 -> （成员变量给定值 -> 构造块或者构造块 -> 成员变量给定值） -> 构造方法
    • 发表于 2021-12-24 00:33:44 回复(0)
    邓帅头像 邓帅
    1. 初始化父类中的静态成员变量和静态代码块 ； 
    2. 初始化子类中的静态成员变量和静态代码块 ； 
    3.初始化父类的普通成员变量和代码块，再执行父类的构造方法；
    4.初始化子类的普通成员变量和代码块，再执行子类的构造方法； 
    发表于 2021-10-23 16:32:50 回复(0)
    牛客425369244号头像 牛客425369244号
    初始化过程， 1先初始化父类静态模块， 2再到子类静态模块， 3再到父类普通， 4再到父类构造， 5再到子类普通 6再到子类构造
    编辑于 2020-09-14 06:34:09 回复(0)
    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 回复(5)
    风屿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)
    提交观点

    问题信息

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

    热门推荐

    相关试题

    扫一扫，把题目装进口袋

    求职之前，先上牛客

    扫描二维码，进入QQ群

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