java基础之——类的初始化顺序

由浅入深，首先，我们来看一下，一个类初始化有关的都有些啥米：

　　静态成员变量、静态代码块、普通成员变量、普通代码块、构造器。（成员方法？貌似跟初始化没有啥关系）

现在我们来看看她们的初始化顺序，

　　从性质上来说，静态的代表的是一个类的属性，普通的是一个对象的属性，“皮之不存，毛将焉附”，没有类，就没法谈对象，所以静态的必须先初始化。

那么静态成员变量与静态代码块之间又是什么关系呢？

　　做了个实验，发现静态成员变量与静态代码块谁放前面谁先执行，但是！！！！注意！！！！这里说的是“执行”是指的把sx=10，这个10赋给sx，而不是sx的初始化，在实验2里在代码块中打断点，可以发现这个时候sx已经被初始化为0，这里我是这样理解的：既然在初始化这个类（或对象）的成员了，那说明已经给它分配好内存了，int分配好内存后默认值为0（基础类型的默认值有false，0，null），不知道这么理解对不对。所以最终的结论是，先初始化成员变量为默认值，然后根据成员变量与代码块的先后顺序进一步初始化。

实验代码如下：

//实验1
private static int sx = 10;

static{

    System.out.println("execute static block");

}



与


//实验2 static{

    System.out.println("execute static block");

}

private static int sx = 10;

　　接着说，普通成员变量与普通代码块和静态的一个道理，就不累述了。

那么构造器与普通成员变量和普通代码块的关系呢？

　　这个我是通过实验得了这么个结论，是成员变量的"=xxx"（和成员变量初始化为默认值区分）和代码块先执行，然后再执行构造器中的。（实验代码最后一并贴出）

 

 

ok到这里为止，一个类的我们简单的说完了，那么类还有继承呢，子类和父类结合到一起的时候又是什么一个顺序呢？

其实挺简单的，子类继承自父类，可以使用父类的非private成员，所以，在在初始化子类之前肯定是要先初始化父类。

 

 

最终的顺序是：

父类静态成员变量初始化为默认值—>

子类静态成员变量初始化为默认值—>

父类按出现的先后顺序执行静态成员变量的“=xxx”和静态代码块—>

子类的按出现的先后顺序执行静态成员变量的“=xxx”和静态代码块—>

父类普通成员变量初始化为默认值—>

子类普通成员变量初始化为默认值—>

父类按出现的先后顺序执行普通成员变量的“=xxx”和静态代码块—>

父类执行构造函数—>

子类的按出现的先后顺序执行普通成员变量的“=xxx”和静态代码块—>

子类执行构造函数—>end

 

实验代码：

package abstractClass;



@SuppressWarnings("unused")

abstract class AbstractDemo {

    {

        System.out.println("execute super block,this.x="+this.x);

    }

    static{

        System.out.println("execute static super block,this.sx="+AbstractDemo.sx);

    }

    public static int SuperPS = 1;

    private static int sx = 1;

    private int x = 1;



    public AbstractDemo(){

        super();

        System.out.println("execute super constractor");

//        this.print();

    }

    

    public abstract void print();

}



@SuppressWarnings("unused")

class DemoImpl extends AbstractDemo{

    public static int PS = 10;

    private static int sx = 10;

    private int x = 10;   //从调试的结果来看，此处是在执行完super()之后执行，然后再接着执行构造器

    {

        System.out.println("execute block,this.x="+this.x);

    }

    static{

        System.out.println("execute static block,this.sx="+DemoImpl.sx);

    }

    public DemoImpl(int x){

        super();  //断点

        System.out.println("execute constractor");

        System.out.println("before init in constractor this.x="+this.x);

        this.x = x;

    }

    

    @Override 

    public void print(){

        System.out.println("this.x="+x);

    }

}



public class TestAbstractDemo{

    public static void main(String[] args) {

        new DemoImpl(100);

    }

}

实验结果：

execute static super block,this.sx=0
execute static block,this.sx=10
execute super block,this.x=0
execute super constractor
execute block,this.x=10
execute constractor
before init in constractor this.x=10