为了叙述方便,我写了个小例子

class Three{

private static int s3 = getS3();

private int y = getY();

public Three(){

System.out.println("Three created and  y = "+y);

}

public int getY(){

System.out.println("Three class getY");

return 12;

}

public static int getS3(){

System.out.println("Three class getS3");

return 44;

}

}

class Two extends Three{

private static int s2 = getS2();

private int x = getX();

public Two() {

System.out.println("Two created and  x = "+x);

}

public int getX(){

System.out.println("Two class getX");

return 11;

}

public static int getS2(){

System.out.println("Two class getS2");

return 44;

}

}

public class One extends Two{

private static int s1 = getS1();

private int z = getZ();

public One(){

System.out.println("One created and  z = "+z);

}

/**

* @param args

*/

public static void main(String[] args) {

One one = new One();

}

public int getZ(){

System.out.println("One class getZ");

return 11;

}

public static int getS1(){

System.out.println("One class getS1");

return 45;

}

}

运行结果:

Three class getS3

Two class getS2

One class getS1

Three class getY

Three created and  y = 12

Two class getX

Two created and  x = 11

One class getZ

One created and  z = 11

解析(为了简便,省略掉所有类的根基类Object):

1.加载类

Java程序运行是从一个静态main()方法开始,此例中也就是 One.main(),当试图调用main方法时,加载器首先需要先加载One的编译代码,也就是One.class文件,加载过程中编译器,会检查是否有基类,如果有基类则继续加载基类,如果该基类还有自身的基类,则第二个基类会被加载,如此类推.上面程序中,先加载One.class,然后Two.class,然后Three.class.

2.静态初始化(静态变量的初始化)

从根基类开始,静态初始化会被执行,然后是下一个导出类的静态初始化,如此类推.上例中根基类Three的静态变量是s3,初始化调用getS3()方法,因此打印 "Three class getS3" ,

接着是导出类Two的静态变量s2的初始化,初始化调用getS2()方法,因此打印 " Two class getS2 " ,然后是导出类One的静态变量s1的初始化,初始化调用getS1()方法,因此打印

"One class getS1 ".

3.在内存堆上分配分配足够的存储空间,创建对象

对象中所有的基本类型都是默认值,对象引用设为null----通过将对象内存设置为二进制0值

4.构造方法的调用

跟静态初始化顺序一样,首先调用基类构造器,调用构造器需要执行两步操作,1.按声明顺序调用成员初始化方法 2.执行构造方法里包含的代码.

上例中,首先从基类Three开始,1. 初始化成员变量y,调用getY(),因此打印" Three class getY ",2.执行构造方法里包含的 代码,因此打印" Three created and  y = 12 " ,接着是导出类Two,执行相同操作,最后是导出类One,执行相同操作

class Super{

int i=10;

Super(){

print()；

i=20;

}

void print(){

System.out.print(i);

}

}

public class Sub{

int j=30;

Sub(){

print();

j=40;

}

void print(){

System.out.print(j);

}

public static void main(){

System.out,.print(new SUb().j);

}

}

结果是03040