复习到继承时写了段代码判断了下子类父类的实例化顺序
这是运行结果

1. class Fu
   
2. {
   
3.         static
   
4.         {
   
5.                 System.out.println("fu静态代码块初始化");       
   
6.         }
   
7.         {
   
8.                 System.out.println("fu构造代码块初始化");       
   
9.         }
   
10.         Fu()
    
11.         {
    
12.                 System.out.println("Fu构造函数初始化");       
    
13.         }
    
14.         Fu(int a){}
    
15.         void show()
    
16.         {
    
17.                 System.out.println("fu show");
    
18.         }
    
19.         int num = 2;
    
20. }
    
21. class Zi extends Fu
    
22. {
    
23.         static
    
24.         {
    
25.                 System.out.println("zi静态代码块初始化");       
    
26.         }
    
27.         {
    
28.                 System.out.println("zi构造代码块初始化");       
    
29.         }
    
30.         Zi()
    
31.         {
    
32.                 System.out.println("zi构造函数初始化");       
    
33.         }
    
34.         /*void show(int b)
    
35.         {
    
36.                         System.out.println(b+"zi show");
    
37.         }*/
    
38.         int num = 3;
    
39.         void show()
    
40.         {
    
41.                         super.show();
    
42.                         //System.out.println("zi show");
    
43.         }
    
44. }
    
45. class ExtendsInstance
    
46. {
    
47.         public static void main(String[] args)
    
48.         {
    
49.                 Zi z = new Zi();
    
50.                 z.show();
    
51.                 //z.show(10);
    
52.                 System.out.println(z.num);
    
53.                
    
54.         }
    
55. }

复制代码

当两个类之间有继承关系时
第一次构造子类的实例时
实例化顺序是：


子类的静态成员初始化语句
子类的静态构造函数
子类的非静态成员初始化语句
父类的静态成员初始化语句
父类的静态构造函数
父类的非静态成员初始化语句
父类的构造函数
子类的构造函数

静态代码块是用于初始化类的，构造代码块是用于初始化所有属于当前类的对象，构造函数是用于初始化对应参数的该类对象的、静态代码块优先于构造代码块优先于构造函数，
创建子类对象的时候会首先加载父类内容

对象的初始化顺序:首先执行父类静态的内容，父类静态的内容执行完毕后，接着去执行子类的静态的内容，当子类的静态内容执行完毕之后，再去看父类有没有非静态代码块，如果有就执行父类的非静态代码块，父类的非静态代码块执行完毕，接着执行父类的构造方法；父类的构造方法执行完毕之后，它接着去看子类有没有非静态代码块，如果有就执行子类的非静态代码块。子类的非静态代码块执行完毕再去执行子类的构造方法。总之一句话，静态代码块内容先执行，接着执行父类非静态代码块和构造方法，然后执行子类非静态代码块和构造方法。

父类静态代码块 ——>子类静态代码块 ——>  父类的非静态构造代码块 ——>  父类的构造方法——> 子类的非静态代码块 ——> 子类构造方法的

这个要记一下、、

补充一下：　如同以上所说的：1．主类的静态成员首先初始化。
　　2．主类的超类的构造方法按照从最高到最低的顺序被调用。
　　3．主类的非静态对象（变量）初始化。
　　4．调用主类的构造方法。
但是需要注意的是：静态对象只初始化一次，非静态对象每次调用时都要初始化。

1、类只有在使用New调用创建的时候才会被JAVA类装载器装入
2、JAVA类首次装入时，会对静态成员变量或方法进行一次初始化,但方法不被调用是不会执行的，静态成员变量和静态初始化块级别相同，非静态成员变量和非静态初始化块级别相同。
先初始化父类的静态代码--->初始化子类的静态代码-->
初始化父类的非静态代码--->初始化父类构造函数--->
初始化子类非静态代码--->初始化子类构造函数
3、创建类实例时，首先按照父子继承关系进行初始化
4、类实例创建时候，首先初始化块部分先执行，然后是构造方法；然后从
本类继承的子类的初始化块执行，最后是子类的构造方法