Java 类成员的初始化顺序

初始化的顺序是先“静态”，（如果它们尚未因前面的对象创建过程而被初始化），后“非静态”。

具体的创建过程：

1.当首次创建某个类对象的时候，或者该类的静态方法/静态域首次被访问时，Java解释器必须查找该类的路径，以定位该类的class文件。

2.然后载入该class（创建一个Class对象），有关静态初始化的动作都会执行。静态初始化只在Class对象首次加载的时候进行一次。

  例如：按照出现顺序执行初始化动作

static int n1 = f(1);
static{
   n3 = f(3);
   //静态域的初始化语句不必担心非法向前引用，但是如果是访问n3，就会发生非法向前引用的错误
   System.out.println("println");
}
static int n2 = f(2);
static int n3;
static int f(int i){
   System.out.println("n"+i);
   return i;
}

 

创建对象或者访问此类的某个静态域/静态方法，打印出来:

n1

n3

println

n2

3.当使用new操作符创建对象的时候，首先将在堆上为待创建的对象分配足够的存储空间。

4.这块存储空间会被清零，这就自动的将类中所有基本类型数据设置成了默认值（数值和字符是0，布尔是false），而引用则被设置成了null。

5.按出现顺序执行所有出现于域(非静态域)定义处的初始化动作。

6.执行构造器。

运行一下下面的例子就都清楚了。

public class MembersInitializeSequence {
   
    public static void main(String[] args){
        Bowl.f();
        System.out.println("实例化一个Bowl对象");
        new Bowl();
        System.out.println("再实例化一个Bowl对象");
        new Bowl();
    }
}

class Cup {
    Cup(int i){
        System.out.println("new Cup("+i+")");
    }
}

class Bowl{
    Cup c1;
    Cup c2 = new Cup(2);
    {
        c1 = new Cup(1);
    }
    static{
        c4 = new Cup(4);
        System.out.println("Bowl中的静态快,静态块只在类加载的时候运行，所以只运行一次");
    }
    static Cup c3 = new Cup(3);
    static Cup c4;
    Bowl(){
        System.out.println("new Bowl()");
    }

    static void f(){
        System.out.println("Bowl中的静态方法f()被访问");
    }
}

 

在类被继承的情况下，初始化的顺序：

1.初始化子类，类加载器在加载它的时候会发现它继承了另外一个类，类加载器要先把父类加载进来。于是开始加载父类，父类的静态部分被按顺序加载。之后子类的静态部分被加载。这样的顺序是考虑子类的静态域可能会依赖父类的静态域；

2.父类的非静态部分被加载；

3.子类指定的父类的构造器；

4.子类的非静态部分被加载；

5.子类构造器的其余部分。

多个层次的继承关系，顺序也同理。

 

例如

public class MembersInitializeSequenceEx {
    public static void main(String[] args){
//        new Cat();
        new Tiger();
    }
}
class Cat{
    int c1 = f1(1);
    int f1(int i){
        System.out.println("Cat unstatic "+i);
        return i;
    }
    {
        System.out.println("Cat unstatic block");
    }
    static int c2 = f2(2);
    static int f2(int i){
        System.out.println("Cat static "+i);
        return i;
    }
    static{
        System.out.println("Cat static block");
    }
    public Cat(){
        System.out.println("new Cat()");
    }
}
class Tiger extends Cat{
    int c3 = f1(3);
    @Override
    int f1(int i){
        System.out.println("Tiger unstatic "+i);
        return i;
    }
    {
        System.out.println("Tiger unstatic block");
    }
    static int c4 = f2(4);
    static int f2(int i){
        System.out.println("Tiger static "+i);
        return i;
    }
    static{
        System.out.println("Tiger static block");
    }
    public Tiger(){
        super();
        System.out.println("new Tiger()");
    }
}