一个java继承与初始化的综合问题

Question

今天看到一个Java程序，没有分析清楚，请高手们帮我分析下这个程序的详细的执行过程
代码：
class Insect{
          private int i = 9;
          protected int j;
          Insect( ){
                    System.out.println("i = " + i + ",j = " + j);
                    j = 39;
          }
          private static int x1 = printInit("static Insect.x1 initialized");
          static int printInit(String s) {
                    System.out.println(s);
                    return 47;
          }
}public class Beetle extends Insect{
          private int k = printInit("Beetle.k initialized");   
          public Beetle(){
                    System.out.println("k = " + k);   
                    System.out.println("j = " + j);
          }
          private static int x2 = printInit("static Beetle.x2 initialized");
          public static void main(String[] args)  {
                    System.out.println("Beetle constructor");
                    Beetle b = new Beetle();
                    
          }
}

Answer 1

1. 加载类Insect，调用printInit()给x1赋值。
2. 加载类Beetle,调用printInit()给x2赋值。
3. 声明定义i，声明j，调用Insect构造方法。
4. 调用PrintInit()定义k, 调用Beetle构造方法。

Answer 2

记得Java语言规范中有详细说明，忘记了。

Answer 3

/**
 * 1. 先要加载main方法,加载之前会先初始化main方法所在的类(Beetle)的静态变量
 * 2. 由于Beetle类继承Insect类,所以在初始化Beetle类中的静态变量之前要先初始化父类(Insect类)中的静态变量
 * 3. 所以会现打印"static Insect.x1 initialized"
 * 4. 然后在初始化子类(Beetle)中的静态变量x2,接着打印"static Beetle.x2 initialized"
 * 5. 进入main体,打印"Beetle constructor"
 * 6. 实例化Beetle类(Beetle b = new Beetle()),事先初始化非静态成员变量,由于Beetle extends Insect
 *        所以先初始化父类的非静态成员变量,然后执行父类的构造方法,打印"i = 9,j = 0"
 * 7. 然后在初始化子类中的非静态成员变量,打印"Beetle.k initialized"
 * 8. 然后再执行子类的构造方法,打印
 *    k = 47
      j = 39
 */

Answer 4

你指的是欲执行子类的main方法前后发生的事情？规则：
1、先静态后动态
2、无论是静态还是动态中，先父类后子类
3、动态先回溯构造器链路
4、根据构造器链路，依次处理每个类：先成员初始化，后构造器（链）
所以
1-->static Insect.x1 initialized并初始化x1为47
2-->static Beetle.x2 initialized并初始化x2为47
进入main方法，进入后，
3-->System.out.println("Beetle constructor"); //这语句有点误导
后面要new对象了，构造器登场
先父类
先初始化i为9,j为0，然后调父类构建器，
4-->System.out.println("i = " + i + ",j = " + j);并修改j值为39
后子类，依然先初始化成员变量，于是
5-->printInit("Beetle.k initialized"); 并赋值k为47
然后调子类构建器
6-->System.out.println("k = " + k);   //47
7-->System.out.println("j = " + j);   //39