概述

在java中，一个类可以包含的元素有变量，方法，代码块，这其中变量可以分为普通变量和静态变量，代码块也有静态代码块和普通代码块。在创建一个对象的时候，这个对象是怎么初始化的呢，这里我们就开始来讲解一下，因为方法只有在调用的时候才会用到，因此这里不将方法的初始化，而主要讲的是变量，代码块以及构造函数的初始化顺序

单个类的初始化

当一个类中包含静态变量，静态代码块，普通变量，普通代码块，以及构造函数时；（注意这里单个类是区别于有继承关系的类来说的，之后会讲到当有继承关系的时候类的初始化顺序）单个类的初始化顺序如下所示

静态变量，静态代码块 –>普通变量，普通代码块 –>构造函数

这其中静态变量与静态代码块的初始化顺序依据在代码中的先后顺序决定，普通变量与普通代码块同样依据在代码中的先后顺序决定。
代码如下。其中为了方便演示变量的初始化，创建了4个类：ParentStaticFieldA，ParentStaticFieldB，ParentNormalFieldC，ParentNormalFieldD这4个类的作用是表示变量的初始化，其代码如下所示：

ParentStaticFieldA.java

public class ParentStaticFieldA {
    public ParentStaticFieldA() {
        System.out.println("ParentStaticFieldA initial");
    }
}

ParentStaticFieldB.java

public class ParentStaticFieldB{
    public ParentStaticFieldB() {
        System.out.println("ParentStaticFieldB initial");
    }
}

ParentNormalFieldC.java

public class ParentNormalFieldC{
    public ParentNormalFieldC() {
        System.out.println("ParentNormalFieldC initial");
    }
}

ParentNormalFieldD.java

public class ParentNormalFieldD{
    public ParentNormalFieldD() {
        System.out.println("ParentNormalFieldD initial");
    }
}

测试类ParentClass如下：

ParentClass.java

public class ParentClass {
    static ParentStaticFieldA a=new ParentStaticFieldA();
    ParentNormalFieldC c=new ParentNormalFieldC();

    static{
        System.out.println("ParentClass static block initial");
    }

    {
        System.out.println("ParentClass normal block initial");
    }
    public ParentClass() {
        System.out.println("ParentClass constructor");
    }

    static ParentStaticFieldB b=new ParentStaticFieldB();
    ParentNormalFieldD d=new ParentNormalFieldD();

    public static void main(String[] args) {
        ParentClass pc=new ParentClass();
    }
}

测试结果如下：

这里对测试类进行说明一下：
1.测试结果前3行说明了，静态代码块与静态变量之间是依据代码的先后顺序初始化的
2.测试结果第1~3行与4~6行以及第7行之间进行比较，说明了静态数据 –> 普通数据 –> 构造函数的初始化顺序

继承关系的类的初始化

当一个类继承某个父类，而父类与子类中同样拥有静态变量，静态代码块，普通变量，普通代码块，以及构造函数时，这种初始化顺序是怎么样的呢？总的来说呢，有静态变量优先静态变量，之后是优先父类初始化，再是子类的初始化，也就是如下的顺序

父类静态变量，代码块 –>子类静态变量，代码块 –>父类普通变量，代码块 –>父类构造函数 –>子类普通变量，代码块–>子类构造函数。

这其中静态变量与静态代码块的初始化顺序依据在代码中的先后顺序决定，普通变量与普通代码块同样依据在代码中的先后顺序决定。
代码如下。其中为了方便演示变量的初始化，创建了4个类：ChildStaticFieldA，ChildStaticFieldB，ChildNormalFieldC，ChildNormalFieldD其代码如下所示：

ChildStaticFieldA.java

public class ChildStaticFieldA {
    public ChildStaticFieldA() {
        System.out.println("ChildStaticFieldA initial");
    }
}

ChildStaticFieldB.java

public class ChildStaticFieldB{
    public ChildStaticFieldB() {
        System.out.println("ChildStaticFieldB initial");
    }
}

ChildNormalFieldC.java

public class ChildNormalFieldC{
    public ChildNormalFieldC() {
        System.out.println("ChildNormalFieldC initial");
    }
}

ChildNormalFieldD.java

public class ChildNormalFieldD{
    public ChildNormalFieldD() {
        System.out.println("ChildNormalFieldD initial");
    }
}

测试类ChildClass继承上面的ParentClass代码如下：

public class ChildClass extends ParentClass{
    static ChildStaticFieldA a=new ChildStaticFieldA();
    ChildNormalFieldC c=new ChildNormalFieldC();

    static{
        System.out.println("ChildClass static block initial");
    }

    {
        System.out.println("ChildClass normal block initial");
    }
    public ChildClass() {
        System.out.println("ChildClass constructor");
    }

    static ChildStaticFieldB b=new ChildStaticFieldB();
    ChildNormalFieldD d=new ChildNormalFieldD();

    public static void main(String[] args) {
        ChildClass pc=new ChildClass();
    }
}

测试结果：

这里对测试类进行说明一下：
1.测试结果前1~3行与4~6说明了，最先初始化的分别是父类的静态数据，之后是子类的静态数据
2.测试结果第7~9行与10行，说明了在初始化父类的与子类的静态数据后，就是初始父类的其他数据，接下来在初始化子类的其他数据