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

复制代码

这段代码运行结果是YXYZ
但是我有点不理解，希望大神能给解释一下~

类中实例变量的初始化在构造函数执行之前执行。
new Z()----->初始化实例变量y调用Y构造函数----->调用z构造函数--------->父类初始化-------->初始化实例变量y，调用构造函数--------调用父类构造函数--------->调用z的构造函数

1. 
   
2. class X
   
3. {
   
4.         Y b=new Y();
   
5.         X()
   
6.         {
   
7.                 System.out.print("X");
   
8.         }        
   
9. }
   
10. class Y
    
11. {
    
12.         Y()
    
13.         {
    
14.                 System.out.print("Y");
    
15.         }
    
16. }
    
17. public class Z extends X
    
18. {
    
19.         
    
20.         Z()
    
21.         {
    
22.                 System.out.println("Z");
    
23.         }
    
24.         {
    
25.                     System.out.println("111111");
    
26.             }
    
27.         Y y=new Y();
    
28.         {
    
29.                     System.out.println("222222222222");
    
30.             }
    
31.         public static void main(String[] args)
    
32.         {
    
33.                 new Z();
    
34.         }
    
35. }

复制代码

运行结果为，
YX111111
Y222222222222
Z



开始代码运行时，首先是z类，由于z类继承与x,所以要首先加载X类，加载x类，首先是加载类的公共变量，也就是 Y b=new Y();，这一句是创建y类对象，所以执行new Y()；时，就要加载Y类，进入Y类，加载Y类的构造函数，所以此时输出Y；加载完Y类后，又回到X类，继续加载X类的构造函数，从而输出X，然后就进入Z类，然后运行加载Z类里的 Y y=new Y();，此时又是创建Y类对象，所以又要加载Y类，进入Y类，加载构造函数，输出Y，Y类运行完后又回到Z类里，然后运行main函数，在main函数里有new Z（）；所以创建Z对象，加载Z类的构造函数，输出Z，这就是运行过程，你可以在一些地方加一些system.out.println();语句，使其输出一些字符观察运行顺序.

根据上面的代码，可见2楼的错了

四五六七八 发表于 2013-12-19 13:31
类中实例变量的初始化在构造函数执行之前执行。
new Z()----->初始化实例变量y调用Y构造函数----->调用z构 ...

你理解貌似错了

用new关键字创建一个类的对象时，先要找到这个类，查看它有没有父类，有的话(如本例中 Z extends X)就先给父类进行初始化(本例中即X类)在进行本类的初始化，按照给一个类进行初始化的顺序进行初始化，本题中只涉及实例变量及构造函数，实例变量的初始化在构造函数前执行。 所以先给父类进行初始化（先执行X中的  Y b=new Y()语句，再执行X的空参构造函数X()）——再给本类进行初始化（先执行Z中的 Y y=new Y()语句，再执行Z的空参构造函数Z()

刘松703 发表于 2013-12-19 13:49
运行结果为，
YX111111
Y222222222222

恩  确实是我搞错了

楼上说明了原理，很清楚，用new关键字创建一个类的对象时，先要找到这个类，查看它有没有父类，有的话就先给父类进行初始化，)在进行本类的初始化，我原来还以为第二个X的输出是继承自X类的，查了下资料，原来构造函数不能被继承。涨知识了。

刘松703 发表于 2013-12-19 13:49
运行结果为，
YX111111
Y222222222222

更正一点，程序是从主函数作为入口的哦！所以“然后运行main函数，在main函数里有new Z（）；所以创建Z对象，加载Z类的构造函数，输出Z”这样的说法是不对的，是开始运行代码时就是从main函数的newZ()语句执行的，这个时候因为Z继承了X，所以要先去初始化X

张利星 发表于 2013-12-19 14:40
更正一点，程序是从主函数作为入口的哦！所以“然后运行main函数，在main函数里有new Z（）；所以创建Z对 ...

确实是表达错了哈哈

谢谢各位的解答！