基础问题请教！关于执行顺序？？？

Question

class Insect {
  int i = 9;
  int j;
  Insect() {
    prt("i = " + i + ", j = " + j);
    j = 39;
  }
    int x1 = prt("static Insect.x1 initialized");
    static int prt(String s) {
    System.out.println(s);
    return 47;
  }
}public class Beetle extends Insect {
  int k = prt("Beetle.k initialized");
  Beetle() {
    prt("k = " + k);
    prt("j = " + j);
  }
  static int x2 =prt("static Beetle.x2 initialized");
  static int prt(String s) {
  System.out.println(s);
  return 63;
  }
  public static void main(String[] args) {
    prt("Beetle constructor");
    Beetle b = new Beetle();
  }
}输出结果是：
static Beetle.x2 initialized
Beetle constructor
static Insect.x1 initialized
i = 9, j = 0
Beetle.k initialized
k = 63
j = 39请帮我解释以下执行顺序，我都糊度了。

Answer 1

楼主现在执行的是beetle类的main函数,所以首先建立beetle的对象
1.首先建立beetle的static对象,因为static比对象本身更早建立
2.调用beetle的构造函数
3.调用先对基类的变量赋值
4.调用基类的构造函数
5.对beetle的非static数据成员赋值
6.调用beetle的构造函数

Answer 2

我觉得应该是
1。首先建立Insect的static对象
2。建立beetle的static对象
3。beetle的main
4。Insect的构造函数
5。Insect的变量赋值
6。beetle的构造函数
7。beetle的变量赋值不知道我理解的有什么问题？

Answer 3

执行顺序一定是从最根类开始，对于每一个类，先static，再其他类变量，接着才是constructor

Answer 4

顺序是: 
1先加载父类然后加载子类,然后先初始化父类的static字段,紧接着是子类的.
2然后执行main函数.
3.执行prt方法.
4.执行父类的构造方法,但在执行之前,先初始化父类的所有非静态字段.紧接着初始化子类的非静态字段,然后执行子类的构造方法

Answer 5

编译器首先访问main()方法(static方法)
然后加载Bettles类－>加载其基类Insect类
然后初始化基类static对象 其次是导出类static对象
然后执行基类的构造器 －> 执行导出类的构造器

Answer 6

我理解的是先初始化基类的static变量，输出static Insect.x1 initialized，然后是子类的static变量，输出static Beetle.x2 initialized，再是main()，输出Beetle constructor，创建一个子类对象，初始化基类的构造函数，然后是子类的构造函数如果是这样的话，输出结果就不一样了~而且k为什么是63，不是47呢~调用prt方法，为什么调用子类中的，不调用基类的~这个也不存在重载，怎么区分是调用哪个？~

Answer 7

程序的执行顺序 1． 当程序用new创建某个类，或访问该类的静态成员或方法时，JVM就根据环境变量classpath指定的路径找到这个类的class文件，准备载入； 
2． 载入动作其实是产生一个相应的Class对象(你用getClass()函数就是返回这个Class 的reference)，同时初始化static成员，执行无名static函数; 
3． 当你用new创建某个类时，该过程首先申请足够的内存空间； 
4． 并把该块空间清为0，再初始化成员变量为初始值； 
5． 再执行成员变量的用户初始化(即申请时的直接赋值)； 
6． 再执行构造函数；  

Answer 8

调试了以下：
新的理解：
1。首先将父类的static成员（是否就是static变量？）初始化
2。子类的static成员初始化
3。执行MAIN函数
4。初始化父类的所有非静态字段
5。父类的构造方法
6。初始化子类的非静态字段
7。执行子类的构造方法也就是说我先前理解的：
类的构造方法发生在类的非静态字段初始化之前
是不对的，而是：
类的非静态字段初始化发生在类的构造方法之前
是否正确？

Answer 9

1、父类的static成员(就是有static关键字的）
2、子类的static成员
3、子类的static块
  static{
    System.out.println(787);
  }
4、父类的static块
5、父类的非static成员
6、子类的非static成员
7、子类的非static块
8、父类的非static块
9、父类的构造方法
10、子类的构造方法请注意：无论多少次new一个对象，静态部分只调用一次（也就是在加载这个类之后调用）
main方法不会自动执行
public class B extends A
{
  static int k=m;//由m的值赋给k可知m一定比k先初始化，也就是父类的静态成员变量比子类先初始化  static{
    System.out.println(2);
  }
  
  int f=l;//由l的值赋给f可知l一定比k先初始化，也就是父类的非静态成员变量比子类先初始化
  
  {
    System.out.println(4);
  }
  
  public B(){
    System.out.println(6);
  }  public static void main ( String[] args )
  {
    B b=new B();
  }
  
}class A{
  static int m=1;  static{
    System.out.println(m);//由此行可知，静态块比静态成员后执行，因为java中不能输出一个未初始化的变量
  }  int l=3;  {
    System.out.println(l);//由此行可知，非静态块比非静态成员后执行，因为java中不能输出一个未初始化的变量
  }
  
  public A(){
    System.out.println(5);
  }}

Answer 10

static应该就是只初始化变量~如果连方法都初始化的话，那肯定会输出一个null了~

Answer 11

static方法好象只有第一次被调用的时候才初始化一次~

Answer 12

以下是本人做测试的代码:
package helloworld;/**
 * <p>Title: </p>
 * <p>Description: </p>
 * <p>Copyright: Copyright (c) 2005</p>
 * <p>Company: </p>
 * @author not attributable
 * @version 1.0
 */public class Child extends Parent{
  static int chi=Child_Static_Init();
  public Child() {
      System.out.println("in Child Constructor");  }
  public static int Child_Static_Init() {
    System.out.println("in Child Static Init");
    return 2;
  }  public static void main(String args[]){
    System.out.println("in Child Main");
    Child a=new Child();  }
}
public class Parent {
  static int par=Parent_Static_Init();
  public Parent() {
      System.out.println("in Parent Constructor");  }
  public static int Parent_Static_Init() {
    System.out.println("in Parent Static Init");
    return 1;
  }}

Answer 13

运行结果是:
in Parent Static Init
in Child Static Init
in Child Main
in Parent Constructor
in Child Constructor
顺序如上述所说