Java初始化顺序

java对象初始化过程：

1. 当运行某程序时（如 java XXX），装载程序先到外面找到该类。在装载过程中，检查其是否有基础类（即超类、父类，extends的类），若有，则将其载入。若基础类含有另一个基础类，则另一个基础类随即也会载入，以此类推。无论其是否准备生成某个基础类的对象，这个过程都会发生。（可试着将对象的创建代码当作注释标注出来，去证实。）
2. 接下来，会先根据基础类执行static初始化（因为static是属于类的，有且只有一个存储空间；而不像对象，每个对象都有自己的非static成员的空间），再在下一个衍生类进行static初始化，以此类推直至目标类。自动初始化保证这个顺序（即从根基础类开始）是非常关键的，因为衍生类的初始化可能要依赖于对基础成员类的正确初始化。
3. 此时，必要的类已全部装载完毕，所以能够创建对象。（如果不创建对象，则在2，运行程序的准备步骤就结束了。）现在开始创建对象。首先，从根基础类开始进行非静态类成员的声明、自动初始化（所有基本数据类型都会设成它们的默认值，而将对象句柄设为 null）（编译器自动对类成员变量进行初始化；成员函数中的变量则不会为其自动初始化，而是在编译时就报错提醒你没有初始化）、根据程序的赋值进行初始值设置、调用构建器，然后再在衍生类中重复以上步骤，直至当前对象。至此，对象的初始化就结束了。

接下来我们通过程序来验证这一顺序。

//: Beetle.java
// The full process of initialization.
class Insect {
    static int x1 = prt("static x1 initialized");
    int i = prt("i initialized");
    int j;
    Insect() {
        prt("start constructing");
        prt("x1 = " + x1 + ", i = " + i + ", j = " + j);
        j = 10;
        prt("end   constructing");
    }
    static int prt(String s) {
        System.out.println("Insect : " + s);
        return 20;
    }
}

public class Beetle extends Insect {
    static int x2 = prt("static x2 initialized");
    int k = prt2("k initialized");
    int m = 1;
    int n = prt2("n initialized");
    Beetle() {
        //super();
        prt("start constructing");
        prt("x2 = " + x2 + ", k = " + k + ", j = " + j);
        prt("end   constructing");
    }
    static int prt(String s) {
        System.out.println("Beetle : " + s);
        return 30;
    }
    //static int prt2(String s) {    
    //the function of prt2 can't be a static function, 
    //because static function can't use m which is not a static variable
    int prt2(String s) {
        System.out.println("Beetle : " 
            + s + ", at ths same time, m = " + m + ", i = " + i);
        return 40;
    }
    public static void main(String[] args) {
        prt("call static prt() before new Beetle");//already overload static function
        Beetle b = new Beetle();
    }
}

1、当运行Beetle程序时，装载程序找到Beetle类，装载它，装载过程中发现其继承Insect类，所以把Insect类装载进来，以此类推（最终到Object类）。
2、从根基础类开始执行static初始化（Object->Insect->Beetle）。为Insect的static类成员（包括成员变量x1与成员函数prt）进行声明，全部声明结束后，执行Insect的静态函数prt，把返回值20赋值给x1。同理，在声明Beetle的Prt后，重写了Insect的prt，此后执行Beetle的静态函数prt，把返回值30赋值给x2。

3、现在，完成了类的装载，开始创建对象。这里省略Object的部分。声明Insect的i、j，为i、j赋予int的默认值0，根据prt的返回值20，为i赋值，进入构建器，打印信息，将j赋值为10。声明Beetle的k、m、n、prt2，调用prt2函数，打印信息，根据函数返回值30，对k赋值，为m赋值，调用prt2函数，打印信息，把返回值30赋值给n。调用Beetle构建器，打印信息。

运行结果：

Insect : static x1 initialized
Beetle : static x2 initialized
Beetle : call static prt() before new Beetle
Insect : i initialized
Insect : start constructing
Insect : x1 = 20, i = 20, j = 0
Insect : end   constructing
Beetle : k initialized, at ths same time, m = 0, i = 20
Beetle : n initialized, at ths same time, m = 1, i = 20
Beetle : start constructing
Beetle : x2 = 30, k = 40, j = 10
Beetle : end   constructing

 

为检验无论其是否准备生成某个基础类的对象，装载程序都会装载基础类，并进行static成员的初始化，我们注释掉main函数中的语句。

    public static void main(String[] args) {
        //prt("call static prt() before new Beetle");//already overload static function
        //Beetle b = new Beetle();
    }

执行结果：

Insect : static x1 initialized
Beetle : static x2 initialized

 

如果写的有问题，欢迎大家指出~