1. class X {
   
2.         Y b = new Y();
   
3.         X() {
   
4.                         System.out.print("X");
   
5.         }
   
6. }
   
7. 
   
8. class Y {
   
9.         Y() {
   
10.                         System.out.print("Y");
    
11.         }
    
12. }
    
13. 
    
14. public class Z extends X {
    
15.         Y y = new Y();
    
16.         Z() {
    
17.                         System.out.print("Z");
    
18.         }
    
19. 
    
20.         public static void main(String[] args) {
    
21.                         new Z();
    
22.         }
    
23. }

复制代码

求解析过程,跟我想的不一样?请高手帮忙看一看!
只想到"xz"但是结果却不是

好乱啊！

寻找人生目标 发表于 2014-5-19 13:34
每个类的构造函数的第一行都有个隐士的super（）；  没声明具体继承哪个类的时候是Objec类     这里我尽 ...

非诚感谢,我明白了!

我觉着是xz啊，明天上机看看

jsjchenlong 发表于 2014-5-19 09:23
代码每一步是怎么执行的，我都给你标注了，你可以看注释，如果实在是理解
不了的话，你就调试执行，你在new ...

非诚感谢,我明白了!

13556793092 发表于 2014-5-19 02:36
1.new Z();执行时 进入Z类构造函数，由于构造函数第一行有一个隐身的super语句 ...

非诚感谢,我明白了!

非诚感谢,各位兄弟!!

1. class X {
   
2.         Y b = new Y();                //第二步 new Y（）加载Y类  
   
3.         X() {
   
4.                         System.out.print("X"); //第四步  输出X
   
5.         }
   
6. }
   
7. class Y {
   
8.         Y() {
   
9.                         System.out.print("Y"); //第三步  输出Y  然后回去第二步 向下执行         //第六步  输出Y
   
10.         }
    
11. }
    
12. public class Z extends X {
    
13.         Y y = new Y();  //第五步  new Y（）； 再加载Y类
    
14.         Z() {
    
15.                         System.out.print("Z");   // 第七步  输出Z
    
16.         }
    
17.         public static void main(String[] args) {
    
18.                         new Z(); //第一步   new Z ，Z的构造函数有隐士的super（）； 然后加载X类
    
19.         }
    
20. }

复制代码

每个类的构造函数的第一行都有个隐士的super（）；  没声明具体继承哪个类的时候是Objec类     这里我尽量简化   看能明白不

代码每一步是怎么执行的，我都给你标注了，你可以看注释，如果实在是理解
不了的话，你就调试执行，你在new没个类的时候，他其实是先去执行父类里的代码，我们知道，每个类都默认继承Object类，每个构造方法默认都调用父类的构造方法，也就是说，子类里的构造方法执行的第一句代码就是Supper（）；这个药搞清楚。好了看下面的代码：
class X
{
    Y b = new Y();//第三次执行的代码；
    X() {
            //第二次执行的代码，这里也有一个super（），去找object的构造方法
                    System.out.print("X");//第六次执行的代码，打印的是X
    }
}

class Y {
    Y() {
            //第四次执行的代码，这里也有一个super（），去找object的构造方法
                    System.out.print("Y");//第五次执行的代码，打印Y
    }
}

public class Z extends X {
    Y y = new Y();//第七次执行的代码，注意这里又会重复执行第四和第五次操作，并且再打印一个Y
    Z() {
            //第一次执行的地方这里其实有一段super()的代码；去找他的父类
            System.out.print("Z");//第八次执行的代码，也是最后执行的代码，打印Z，所以结果就是YXYZ
    }

    public static void main(String[] args) {
  
        new Z(); //(注意如果实在是理解不了，就去调试看程序是怎么执行的，如果能就看我给你写的步骤)在这段代码前面给个断点进行dubg调试，然后俺F6进行一步一步执行看结果变化
    }
}

发表一下个人的观点：
执行new Z()之前的准备：
1.执行主函数，加载主函数所属类Z类，Z类继承X类，因此先加载X类，遇到newY()，加载Y类并初始化对象输出Y；
2.调用子类中的隐身super语句完成父（X）类初始化，打印X；
3.加载Z类，又遇到newY()，创建Y类对象并初始化，打印Y；
4.当new()Z时，调用Z类构造函数，打印Z；

1.new Z();执行时 进入Z类构造函数，由于构造函数第一行有一个隐身的super语句