1. 
   
2. <p> </p>

复制代码

class X {
Y y = new Y();//改成 Y y = new Y();〉〉〉〉为什么输出的结果还是YXYZ的呢  怎么没有覆盖
X() {
   System.out.print("X");
}
}
class Y {
Y() {
   System.out.print("Y");
}
}
public class Z extends X {
Y y = new Y();
Z() {
   System.out.print("Z");
}
public static void main(String[] args) {
   new Z();
}
}

new一个子类对象的时候有父类对象的生成，要不你怎么可以继承父类中的成员变量呢，在内存中生成一个子类SubClass的对象区域，在此区域当中还包含着一个父类(Base)对象
所以第一个Y是父类X中Y new对象时，Y的构造函数产生的（比X构造函数早执行），然后父类的构造函数产生了X，然后子类产生对象的时候Y又会产生一个对象所以第二个Y是子类中产生的，最后子类调用构造函数产生Z
结果是YXYZ

你提的问题不是很清楚，在继承中，子类执行时，会先执行父类的代码。
在这道题中：new Z();这句话的执行过程是：
1.    先执行父类X的代码：Y y = new Y();--->打印Y
     X();---------------------------------------->打印X；
2.执行子类class Z中的代码：Y y = new Y();--->打印Y；
Z()；--------------------------------------------->打印Z
至于你说的覆盖，在子类中没有看到你对付类方法的重写，所以还是执行上面的顺序

1. class X
   
2. {
   
3.         Y y = 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
    
17. {
    
18.         public static void main(String[] args)
    
19.         {
    
20.                 new X();
    
21.         }
    
22. }

复制代码

此时结果是：YX

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

复制代码

此时结果为：YZ

1. class X
   
2. {
   
3.        
   
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.         Y y = new Y();
    
19.         Z()
    
20.         {
    
21.                 System.out.println("Z");
    
22.         }
    
23.         public static void main(String[] args)
    
24.         {
    
25.                 new Z();
    
26.         }
    
27. }

复制代码

结果为：XYZ
我想你肯定明白了

按照代码的执行的顺序，首先执行父类，class X  ，创建y对象，输出y  ，x()方法输出x ；然后执行子类的代码同样创建y对象，输出y，z（）方法输出z！   结果当然就是yxyz  ，

class X {　 　　　Y y = new Y(); 　　　　 //  4   　　　　
　　X() {   
　　　　System.out.print("X");　　　 //  3  X
　　 }
}

class Y {
　　Y() {   
　　　　System.out.print("Y");// 　　 5  Y
　　 }
}

public class Z extends X {
　　Y y = new Y();  　　　　　　　//   顺序：1 　 Y
　　Z() {         
　　　　　super();　　　　  //  2 （重点是这里，有一个隐式的语句！super（））   
　　　　 System.out.print("Z"); 　　　// 6  Z
　　}　

　　public static void main(String[] args) {   
　　　　 new Z();
　　}
｝



注意构造函数里面的隐式语句问题。。。。。。。。。。。