1. <div class="blockcode"><blockquote>public class Code {
   
2.         static {                                                                        //Code静态代码块
   
3.                 System.out.println("Code 静态代码块 ①");
   
4.         }
   
5.         
   
6.         public static void main(String[] args) {        //主方法
   
7.                         Zi z = new Zi();                                                //创建Zi类对象
   
8.         }
   
9. }
   
10. class Fu {
    
11.         static {                                                                        //Fu静态代码块
    
12.                 System.out.println("Fu 静态代码块 ②");
    
13.         }
    
14.         
    
15.         {                                                                                        //Fu构造代码块
    
16.                 System.out.println("Fu 构造代码块 ③");
    
17.         }
    
18.                
    
19.         public Fu() {                                                                //Fu构造方法        
    
20.                 super();
    
21.                 System.out.println("Fu构造方法 ④");                        
    
22.         }
    
23. }
    
24. 
    
25. class Zi extends Fu {
    
26.         static {                                                                        //Zi静态代码块        
    
27.                 System.out.println("Zi 静态代码块 ⑤");               
    
28.         }
    
29.         
    
30.         {                                                                                        //Zi 构造代码块
    
31.                 System.out.println("Zi 构造代码块 ⑥");               
    
32.         }
    
33.         
    
34.         public Zi() {                                                                //Zi构造方法
    
35.                 super();        
    
36.                 System.out.println("Zi 构造方法 ⑦");
    
37.         }
    
38. }

复制代码

运行结果:
Code 静态代码块 ①
Fu 静态代码块 ②
Zi 静态代码块 ⑤
Fu 构造代码块 ③
Fu 构造方法 ④
Zi 构造代码块 ⑥
Zi 构造方法 ⑦


Zi 构造方法⑦  里不是有一句super();么,明明调用了 Fu 构造方法④,为什么执行顺序是 3467,而不是3647

前边的我就不叙述了，因为在java中是分层初始化的，所以父类先初始化，但是当运行到父类构造方法的时候，发现还有父类构造代码块，所以就先执行父类代码块，然后接着是父类构造方法，然后才是子类的，所以是3467.

好复杂   看的111111111

yunmu 发表于 2016-4-9 23:02
前边的我就不叙述了，因为在java中是分层初始化的，所以父类先初始化，但是当运行到父类构造方法的时候，发 ...

照这样理解,子类中的 super(); 不就没执行么?

加油加油

静态代码块优于主函数执行，构造代码块先于构造函数执行，所以执行顺序从高到低的是静态代码块、构造代码块、构造函数

yaolv7 发表于 2016-4-9 23:27
照这样理解,子类中的 super(); 不就没执行么?

执行了啊，要不然怎么先去执行父类的啊

yaolv7 发表于 2016-4-9 23:27
照这样理解,子类中的 super(); 不就没执行么?

执行了啊，要不然怎么先去执行父类的啊

yunmu 发表于 2016-4-11 00:24
执行了啊，要不然怎么先去执行父类的啊

如果执行的话,不是应该
Fu 构造方法 ④  执行完,接着执行 Zi 构造方法 ⑦么?怎么下面是执行 Zi 构造代码块 ⑥??难道这还有个判断?

yaolv7 发表于 2016-4-11 09:13
如果执行的话,不是应该
Fu 构造方法 ④  执行完,接着执行 Zi 构造方法 ⑦么?怎么下面是执行 Zi 构造代码 ...

建议你看看，基础第8天十一个视频，有可能不一样，就是继承那一今天的面试题。 静态代码块随着类的加载而执行，优先于主函数，只执行一次。构造代码块随着对象的创建而执行，优先于构造方法执行。
执行顺序：
     1、静态代码块(只执行一次)
     2、构造代码块(优先构造方法)
     3、构造方法
子类中所有的构造方法默认都会访问父类中空参数的构造方法
        因为子类会继承父类中的数据，可能还会使用父类的数据。
        所以，子类初始化之前，一定要先完成父类数据的初始化。