class God {
        Test t = new Test();  //第4步
        God(){  //第2步
                System.out.println("我是父类God");
        }
}

class Test {
        Test(){
                System.out.println("我是测试类");
        }
}

public class Demo33 extends God {
        {
                System.out.println("我是构造代码块");  //第3步
        }

        Demo33(){
                System.out.println("我是子类Demo33");  //第5步
        }

        Test t = new Test();  //第1步

        public static void main(String[] args) {
                        Demo33 dm=new Demo33();
        }
}

想问下：new Demo33()后怎么不是God()(第2步)先走，还有就是new完Test()(第1步)后的对象和构造快(第3步)的建立没有任何关系是吧？

1. class God {
   
2.         Test t = new Test();  //这是第1步不是第4步
   
3.         God(){  //第2步
   
4.                 System.out.println("我是父类God");
   
5.         }
   
6. }
   
7. 
   
8. class Test {
   
9.         Test(){
   
10.                 System.out.println("我是测试类");
    
11.         }
    
12. }
    
13. 
    
14. public class Demo33 extends God {
    
15.         {
    
16.                 System.out.println("我是构造代码块");  //第3步
    
17.         }
    
18. 
    
19.         Demo33(){
    
20.                 System.out.println("我是子类Demo33");  //第5步
    
21.         }
    
22. 
    
23.         Test t = new Test();  //这是第4步不是第1步
    
24. 
    
25.         public static void main(String[] args) {
    
26.                         Demo33 dm=new Demo33();
    
27.         }
    
28. }

复制代码

1，首先加载父类God，读到 Test t = new Test(); 加载了Test类，并创建了对象，所以调用构造方法进行对象的初始化，所以第一步为：我是测试类
2，然后执行父类God的构造方法God，得到第二步：我是父类God。
3，父类执行完之后，加载子类Demo33，执行构造代码块，对该类中所有对象进行统一初始化，并且只执行一次。得到第三步：我是构造代码块。
4，执行到第二个Test t = new Test(); 再一次创建了该类的对象并调用构造函数进行了初始化。所以得到第四步：我收测试类。
5，最后执行main方法，创建了Demo33的对象，调用构造方法进行初始化，得到第五步：我是子类Demo33。

来男. 发表于 2014-5-3 18:09
那“自身属性初始化执行顺序优于自身构造函数”是在哪规定的呀？

连对象属性的还没加载进堆中，怎么能用构造函数去new一个对象呢，必须是先加载属性，这是情理之中的！！！

Lin0411 发表于 2014-5-3 18:24
顺序是这样的：
我是测试类
我是父类God

嗯，嗯，我觉得这句很重要：java是先加载成员变量到堆中，故会先输出‘我是测试类’（God中的t输出的！！）。

顺序是这样的：
我是测试类
我是父类God
我是构造代码块
我是测试类
我是子类Demo33

类中是先执行构造代码块，再执行构造函数内的代码。而在继承关系中是先执行父类的构造函数再执行子类的构造函数，又因为在new一个对象的时候，java是先加载成员变量到堆中，故会先输出‘我是测试类’（God中的t输出的！！），接着便运行God父类中的构造函数，输出‘我是父类God’，然后轮到子类，运行构造代码块输出‘我是构造代码块’，然后是子类t加载后输出‘我是测试类’，接着再执行子类构造函数，输出‘我是子类Demo33’。

skill20 发表于 2014-5-3 18:03

那“自身属性初始化执行顺序优于自身构造函数”是在哪规定的呀？