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 B extends X {
    
15.         Y y = new Y();
    
16.         B() {
    
17.                 super();//这句可省
    
18.                 System.out.print("Z");
    
19.         }
    
20. 
    
21.         public static void main(String[] args) {
    
22.                         new B();
    
23.         }
    
24. }

复制代码

这段代码执行结果是什么？
我的分析是这样的：
先执行main方法里的new B();
然后到B类里执行构造方法super();
接下来执行X类的构造方法打印“X”
最后执行B类构造方法里第二句打印“Z”
所以我分析的结果最后打印出“XZ”
那么在该程序中Y类根本没用到？

cz2861856 发表于 2012-10-18 12:43
用到了，看代码
首先执行的是new B()
让后到B类里面，发现B类里面先创建了一个Y对象，

叫你这样说，输出应该是YYXZ了，怎么是YXYZ呢

对象的执行过程是：

1)找到class文件并加载到内存中。

2)执行该类中的static代码块，如果有的话，并给类进行初始化。

3)在堆内存中开辟空间，分配内存地址。

4)在堆内存中建立对象的特有属性。并进行默认初始化。

5)对属性进行显示初始化。（如果有的话）

6)对对象进行构造代码块初始化。（如果有的话）

7)对对象进行对应的构造函数初始化。

8)将内存地址付给栈内存中的引用变量。。（如果有的话）
而且之所以子类中的构造函数存在super，就是因为父类中的数据子类可以直接获取。所以子类对象在建立时，需要先查看父类是如何对这些数据进行初始化的。

用到了，看代码
首先执行的是new B()
让后到B类里面，发现B类里面先创建了一个Y对象，
再去Y类里，发现Y类的构造函数输出Y，所以这时输出Y
接下来又回到B的构造函数里面，你也知道会隐式调用父类构造函数super();
既然父类是x，就x类里边，发现又new了一个Y对象，再次调用Y的构造函数，然后调用X的构造函数。
最后回到B类来，调用B的构造函数。
所以就是YXYZ

给你一个清晰的执行过程
new B()
1　执行X类的构造器
  * X类的显示初始化语句--Y
  * X构造器的内容 -- X
2　执行B类的构造器
  * B类的显示初始化语句--Y
  * B类的构造器内容 -- Z

结果是YXYZ
我的分析是这样的：
先执行main方法里的new B();
然后到B类里执行构造方法super(),首先执行父类X的Y b = new Y();打印“Y”.再执行B的构造方法打印“X”.
然后执行B类的 Y y = new Y();打印“Y”.再执行B类的构造方法中的System.out.print("Z");打印“Z”.

你自己运行一下不就知道Y类用没用到。。。。。。

打印的是YXYZ

在创建对象实例的时候，是先将成员变量初始化，才运行的构造函数。
打印的两个Y一个是继承自父类的，一个是自己的