class X
{
Y b = new Y();
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();
}
}
初学者，不是太懂，求详解，谢谢！

package Day21;
class X
{
        Y b = new Y();
        X()
        {
           System.out.print("X");
        }
}
class Y
{
   Y()
   {
      System.out.print("Y");
   }
}
public class Test1 extends X
{
        Y y = new Y();
        Test1()
        {
                super();//这里省略这个.
                System.out.print("Z");
        }
        public static void main(String[] args)
        {
           new Test1();//程序会先加载Test1,加载成员.遇到类Y->加载Y的构造函数->加载Test1的构造函数,因为它继承了X类,会先调用父类
           //的构造函数,载加类X,X类中有Y的成员,调用Y的构造函数.->加载完后,调用Test1类的.
           //说明,只要程序中New了新的成员,就会加载其类,并在栈内存开辟空间.
        }
}

1. //创建类X
   
2. class X
   
3. {
   
4.         //创建类型为Y的对象
   
5.         Y b = new Y();
   
6.         //类X的无参数构造函数，功能是初始化打印字符串X
   
7.         X()
   
8.         {
   
9.                 System.out.print("X");
   
10.           }
    
11. }
    
12. //创建类Y
    
13. class Y
    
14. {
    
15.         //类Y的无参数构造函数，功能是初始化打印字符串Y
    
16.         Y()
    
17.         {
    
18.       System.out.print("Y");
    
19.         }
    
20. }
    
21. //创建类Z，继承类X，即X是Z的父类
    
22. public class Z extends X
    
23. {
    
24.         //创建一个类型为Y的对象
    
25.         Y y = new Y();
    
26.         //类Z的无参数构造函数，功能是初始化打印字符串Y
    
27.         Z()
    
28.         {
    
29.                 System.out.print("Z");
    
30.         }
    
31.         //主函数
    
32.         public static void main(String[] args)
    
33.         {
    
34.                 //创建一个匿名对象，类型为Z
    
35.            new Z();
    
36.         }
    
37. }
    

复制代码

打印结果为：YXYZ

陈圳 发表于 2013-3-3 14:34
程序会先加载Test1,加载成员.遇到类Y->加载Y的构造函数->加载Test1的构造函数,因为它继承了X类,会先调用父类
           //的构造函数,载加类X,X类中有Y的成员,调用Y的构造函数.->加载完后,调用Test1类的.
           //说明,只要程序中New了新的成员,就会加载其类,并在栈内存开辟空间.

请问 为什么在调用Test1的父类X的时候是先加载的构造函数，然后再加载X类中的成员 Y b。而在new Z()的时候是先走成员Y y然后再是Test1的构造函数。

package ceshi;

class X //建立一个类名为X
{
        Y b = new Y();//在X中定义一个B指向Y的对象,此Y为Y类中的对象。初始化输出Y
        X()
        {
                System.out.print("X");//定义一个X的构造方法输出字符串X。
        }
}
class Y //建立一个类Y
{
        Y()
   {
      System.out.print("Y");//定义一个Y的构造方法输出字符串Y。
   }
}
public class Z extends X //建立一个类Z继承X
{
               
                Y y = new Y(); //定义一个y指向Y的对象，此y等于Y类中的对象。初始化后输出Y，此处为第一步！
                Z()                         //定义一个Z的构造函数，输出字符串Z。这里是关键，定义完因为没调用所以不会显示，直接跳到主函数中
                {
                //这里隐藏了super.X（）；输出X。
                System.out.print("Z");
                }
                public static void main(String[] args)
                {
                        new Z();//匿名对象Z，默认调用构造方法初始化，输出字符串“Z”，但因为继承关系所以先输出super.X所以打印先输出X的构造方法
                }
}


上面已经全部注释了：下面在给你解读一下，从第一步开始 程序从第一步开始，新建Y类对象 将内存地址赋给Z方法的对象y，要知道新建一个对象要初始化，而这里建立的对象Y类的对象指向 Z类中的对象y，那么就需要调用Y类的构造方法，即打印输出Y。
第二步定义Z（）的构造函数，因为没调用所以不输出
第三部进入main方法中，新建了一个匿名对象Z，这里又建立对象了所以要初始化，调用Z类中的构造方法，但是因为Z类继承X类，所以Z类是X的子类，所以要先调用父类的构造方法，即隐藏的super.X()，所以输出了X，而因为X类加载进内存，X在类中操作了Y b = new Y();所以再次输出Y，最后Z初始化自己输出Z。
打印结果即为YXYZ。

加载顺序也不是很清楚了

谢谢大家的详细解答

{:soso_e134:}