1. package test2;
   
2. class X {
   
3.        
   
4.         X() {
   
5.                         System.out.print("X");
   
6.         }
   
7.         Y b = new Y();
   
8. }
   
9. 
   
10. class Y {
    
11.         Y() {
    
12.                         System.out.print("Y");
    
13.         }
    
14. }
    
15. 
    
16. public class Test {
    
17.         public static void main(String[] args) {
    
18.                         new X();               
    
19.         }
    
20. }
    
21. //输出结果YX
    
22. //不是X类的构造函数先执行么？我理解的输出结果XY

复制代码

你再加一个 static 方法，一个static 代码块,一个 空名称代码块
然后再看看初始化顺序。

1. class T
   
2. {
   
3.         {System.out.println("空代码块");}
   
4.         static {System.out.println("static代码块");}
   
5.        
   
6.         T()
   
7.         {
   
8.                 System.out.println("构造函数");
   
9.         }
   
10.         public static void t()
    
11.         {
    
12.                 System.out.println("static函数");
    
13.         }
    
14. }
    
15. class Test1c
    
16. {
    
17.         public static void main(String[] args)
    
18.         {
    
19.                 T.t();
    
20.                 System.out.println("-----------");
    
21.                 new T();
    
22.                
    
23.                 byte b1=3,b2=4,b;
    
24.                 //b=b1+b2;
    
25.                 b=127;
    
26.                 int i;
    
27.                 i=b1+b2;
    
28.                 //i=3.3+2.2;
    
29.                 float f;
    
30.                 f=2.2f+3;
    
31.                
    
32.         }
    
33. }

复制代码

不错
嗯

Y b = new Y();成员变量类加载的时候就初始化了，构造函数，你不new对象就不会被执行。

受教了..记住初始化顺序

你要搞清楚这个问题，需要了解java类成员的初始化顺序
成员变量会在构造方法之前初始化

不是 当构造函数初始化的时候 先初始化更加细节的部分 在这里 对于一个类内部新建类来说 内部新建的那个类会先存在 然后再初始化本类的构造函数 跟this必须在构造函数第一行的原因一样

Boss星月 发表于 2015-7-3 17:41
class X {  //加载类时已经写执行了new
        X() {
                System.out.print("X");

我就想知道为什么先调Y b = new Y();

class X {  //加载类时已经写执行了new
        X() {
                System.out.print("X");
        }
        Y b = new Y();//掉了 Y的构造
}
class Y {
        Y() {
                System.out.print("Y");
        }
}

public class Test {
        public static void main(String[] args) {
                new X();//掉X的时候先掉了Y b = new Y()
        }
}