Java 程序的加载运行过程

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

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