java static初始化
public class Chapter5_test5 {

/**
* @param args
*/
public static void main(String[] args) {

System.out.println("Error");
new Cupboard();
System.out.println("Error");
new Cupboard();

table.f2(1);
cupboard.f3(1);

}
static Table table=new Table();
static Cupboard cupboard=new Cupboard();
}
class Bowl{
Bowl(int marker){
System.out.println("Bowl("+marker+")");
}
void f1(int marker){
System.out.println("f1("+marker+")");
}
}
class Table{
static Bowl bowl1=new Bowl(1);
Table(){
System.out.println("Table");
bowl2.f1(1);

}
void f2(int marker){
System.out.println("f2("+marker+")");
}
static Bowl bowl2=new Bowl(2);
}
class Cupboard{
Bowl bowl3=new Bowl(3);
static Bowl bowl4=new Bowl(4);
Cupboard(){
System.out.println("Cupboard(");
bowl4.f1(2);
}
void f3(int marker){
System.out.println("f3("+marker+")");
}
static Bowl bowl5=new Bowl(5);
}

请问里面的初始化是怎么开始和完成的

[解决办法]

Java code

/*1、对象的初始化(1)非静态对象的初始化在创建对象时，对象所在类的所有数据成员会首先进行初始化。基本类型：int型，初始化为0。如果为对象：这些对象会按顺序初始化。※在所有类成员初始化完成之后，才调用本类的构造方法创建对象。构造方法的作用就是初始化。(2)静态对象的初始化程序中主类的静态变量会在main方法执行前初始化。不仅第一次创建对象时，类中的所有静态变量都初始化，并且第一次访问某类（注意此时未创建此类对象）的静态对象时，所有的静态变量也要按它们在类中的顺序初始化。2、继承时，对象的初始化过程(1)主类的超类由高到低按顺序初始化静态成员，无论静态成员是否为private。(2)主类静态成员的初始化。(3)主类的超类由高到低进行默认构造方法的调用。注意，在调用每一个超类的默认构造方法前，先进行对此超类进行非静态对象的初始化。(4)主类非静态成员的初始化。(5)调用主类的构造方法。*///不知我下面写的步骤，是否有问题，public class Chapter5_test5 {    public static void main(String[] args)     {        //13.主类的静态成员初始化完成，开始执行main()主函数，        //14.首先，输出: “Error”,        //15.然后，执行new Cupboard(),在调用Cupboard类的构造函数之前，还是先进行非静态成员初始化动作，所以执行Bowl bowl3=new Bowl(3),那么，同理（8，9步骤），输出: “Bowl(3)”,        //16.接着，调用Cupboard类的构造函数，执行输出语句，输出: “Cupboard(”,        //15.最后，执行bowl4.f1(2)，输出: “f1(2)”,        //16.输出: “Error”,        //17.执行new Cupboard(),在调用Cupboard类的构造函数之前，还是先进行非静态成员初始化动作，所以执行Bowl bowl3=new Bowl(3),那么，同理（8，9步骤），输出: “Bowl(3)”,        //18.然后，调用Cupboard类的构造函数，执行输出语句，输出: “Cupboard(”,        //19.最后，执行bowl4.f1(2)，输出: “f1(2)”,        //20.执行table.f2(1),输出: “f2(1)”,        //21.执行cupboard.f3(1)，输出: “f3(1)”,        System.out.println("Error");        new Cupboard();        System.out.println("Error");        new Cupboard();                table.f2(1);        cupboard.f3(1);    }        static Table table=new Table();     //1,先执行主类的静态成员，此动作在main()方法之前，    //2,执行static Table table=new Table()，在调用Table类的构造函数前，还是先执行Table类的静态成员的初始化，后执行Table类的非静态成员初始化动作，最后执行Table类的构造函数，    //3,所以，执行Table类的static Bowl bowl1=new Bowl(1)，那么，在调用Bow1类的构造函数前，判断由于Bow1没有静态成员以及非静态成员，所以直接执行构造函数的输出语句，输出: “Bowl(1)”,    //4,然后，继续执行Table类的static Bowl bowl2=new Bowl(2)，那么，在调用Bow1类的构造函数前，判断由于没有非静态成员（静态成员只执行一次），所以直接执行构造函数的输出语句，输出：“Bowl(2)”，    //5.执行完Table类的静态成员，检查非静态成员，没有，则直接调用Table类的构造函数，执行println输出语句，输出: “Table”,    //6,继续执行Table类的构造函数中的bowl2.f1(1)，输出: “f1(1)”,        static Cupboard cupboard=new Cupboard();    //7.执行static Cupboard cupboard=new Cupboard(),在调用Cupboard类的构造函数前，还是先执行Cupboard类的静态成员的初始化，后执行Cupboard类的非静态成员初始化动作，最后执行Cupboard类的构造函数，    //8.接着，执行Cupboard类的static Bowl bowl4=new Bowl(4),那么，在调用Bow1类的构造函数前，判断由于没有非静态成员（静态成员只执行一次），所以直接执行构造函数的输出语句，输出：“Bowl(4)”，    //9.继续执行Cupboard类的static Bowl bowl5=new Bowl(5),那么，同理，输出: “Bowl(5)”,    //10.在调用Cupboard类的构造函数之前，还需执行Cupboard类的非静态成员初始化动作，所以执行Bowl bowl3=new Bowl(3),那么，同理，输出: “Bowl(3)”,    //11.最后，调用Cupboard类的构造函数，执行println输出语句，输出: “Cupboard(”,    //12,继续执行Cupboard类的构造函数中bowl4.f1(2)，输出: “f1(2)”,    }class Bowl{    Bowl(int marker)    {        System.out.println("Bowl("+marker+")");    }        void f1(int marker)    {        System.out.println("f1("+marker+")");    }}class Table{    static Bowl bowl1=new Bowl(1);        Table()    {        System.out.println("Table");        bowl2.f1(1);        }        void f2(int marker)    {        System.out.println("f2("+marker+")");    }        static Bowl bowl2=new Bowl(2);}class Cupboard{    Bowl bowl3=new Bowl(3);    static Bowl bowl4=new Bowl(4);        Cupboard()    {        System.out.println("Cupboard(");        bowl4.f1(2);    }        void f3(int marker)    {        System.out.println("f3("+marker+")");    }        static Bowl bowl5=new Bowl(5);}