java 父类子类静态成员，实例成员，构造函数初始化的顺序

java中的成员分为：
 静态成员 : 静态成员变量，静态代码块，静态成员方法
 实例成员：实例成员变量，实例代码块，实例成员方法
 构造方法
 析构方法
 下面做的实验，主要是验证 当new 一个子类时，子类和它的父类中  静态成员变量，静态代码块，实例成员变量，实例代码块，构造方法 这5部分的执行顺序

 父类代码：

package _test; 
  
 public abstract class AbstractClass { 
     private static N n = new N();   //静态成员变量 
      
     static{                        //静态代码块 
         System.out.println(2); 
     } 
      
     private M m = new M();       //实例成员变量 
       
     {                            //实例代码块 
         System.out.println(6); 
     } 
      
     public AbstractClass(){       //无参数的构造函数 
         System.out.println(7); 
     } 
      
     public AbstractClass(int i){  //有参数的构造函数 
         System.out.println(i); 
     } 
      
 } 
  
 class M{ 
     public M(){ 
         System.out.println(5); 
     } 
 } 
  
 class N{ 
     public N(){ 
         System.out.println(1); 
     } 
 } 

子类代码：

package _test; 
  
 public class SubClass extends AbstractClass { 
     static{                         //静态代码块 
         System.out.println(3); 
     } 
      
     private static U u = new U();   //静态成员变量 
      
     {                              //实例代码块 
         System.out.println(8); 
     } 
      
     private I i = new I();        //实例成员变量     
      
     public SubClass(){                 
         super();         //显式调用父类的构造函数;如果不写，也会隐式调用 
         System.out.println(10); 
     } 
 } 
  
 class I{ 
     public I(){ 
         System.out.println(9); 
     } 
 } 
  
 class U{ 
     public U(){ 
         System.out.println(4); 
     } 
 } 

在main中 执行语句  SubClass sc = new SubClass();
 执行结果是: 1 2 3 4 5 6 7 8 9 10
 
执行过程分析：
 当new 子类时，
 首先由JVM找出相关的父类，先加载父类再加载子类；  【对应结果中的 1 2 3 4】
 然后，进入子类的构造方法内部，先隐式地调用super()（也可显示调用无参数的或有参数的）来构造父类；【对应结果中的 5 6 7】
 然后，初始化子类中的实例成员，（这一步在构造方法内部并没有显式的代码） ；【对应结果中的8 9】
 最后，执行super()后面的其它语句。  【对应结果中的10】
 
由上面执行过程可知：
 在构造方法里，执行语句super()和它后面的语句之间存在一个“过程”，在这个“过程"中执行的操作：初始化实例成员变量和执行实例代码块。
 （这个过程应该也是由JVM默认执行的。）