Java类的初始化顺序

title picture

  最近在看回顾Java基础的时候，发现看似很简单的类初始化的顺序却并不是那么简单（往往越是简单的东西反而越容易出错呢），所以我觉得还是把它写下来，作为自己的备忘录比较好。既然都记录了我觉得我还是记录得比较全面的较好，所以显得有点啰嗦。

普通类的初始化（不存在继承，内部类的时候）

  为了更详细的验证类的初始化顺序，首先我创建了一个被另一个类使用的类B.java

public class B {    private int varOneInB = initInt("varOneInB"); // 6 14    private static int staticVarOneInB = initInt("staticVarOneB");  // 4      private int varTwoInB = initInt("varTwoInB"); // 7 15    private static int staticvarTwoInB = initInt("staticvarTwoInB"); // 5    /**     * 构造方法     */    public B() {        System.out.println("B  constructor"); // 8 16    }    /**     * 用于对int类型的变量赋值     * @param varName     * @return     */    private static int initInt(String varName) {        System.out.println(varName + " init");        return 2017;    }}

  然后我创建了一个A类来验证初始化顺序，并且在该类中同时使用的static变量和static块等。

public class A {    private int varOneInA = initInt("varOneInA"); // 11    private static int staticVarOneInA = initInt("staticVarOneInA"); // 1     {          int varTwoInA = initInt("varTwoInA"); // 12    }    static {          int staticvarTwoInA = initInt("staticvarTwoInA");  // 2    }    private B b = new B(); // 13    private static B staticB = new B(); // 3    /**     * 构造方法     */    public A() {        System.out.println("A  constructor"); // 17    }    /**     * 用于对int型变量赋值     * @param varName     * @return     */    private static int initInt(String varName) {        System.out.println(varName + " init");        return 2017;    }    public void run() {        System.out.println("run be called");// 23    }    public static void main (String[] args) {        System.out.println("start running");// 9        A a = new A();// 10        a.run();// 18    }}

运行后结果为：

staticVarOneInA initstaticvarTwoInA initstaticVarOneB initstaticvarTwoInB initvarOneInB initvarTwoInB initB  constructorstart runningvarOneInA initvarTwoInA initvarOneInB initvarTwoInB initB  constructorA  constructorrun be called

  对《Think in java》这本书里面的关于初始化顺序的总结进行归纳如下：

注意：即使变量定义散布于方法定义之间，它们仍旧会在任何方法（包括构造器）被调用之前得到初始化。

1. 即使没有显示地使用static关键字，构造器实际上也是静态方法。因此，当首次创建类的对象时（构造器可以看出静态方法），或者类的静态方法/静态域被首次访问时，Java解释器必须查找类路径。
2. 然后载入class，有关静态初始化的所有动作都会执行（所以静态初始化只在Class对象首次被加载的时候进行一次）。
3. 当使用new创建对象的时候，首先将在堆上为对象分配足够的存储空间。
4. 这块存储空间会被清零，这就自动将Dog对象中的所有基本类型数据都设置成了默认值（对数字来说就是0，对布尔类型和字符类型也相同），而引用就则被设置成了null。
5. 执行出现于字段定义出的初始化动作。
6. 执行构造器。

  有了上面的知识点，再来看上面的结果。我用数字1 2 3做了标记，括号后的阿拉伯数字表示上面代码对应的地方。

• 在类A中执行main方法，由于main()是静态方法，必须加载A类，然后起静态域staticVarOneInA(1)，staticvarTwoInA(2)，staticB(3)被初始化。
• 在staticB被初始化的时候，导致B类被加载，因为是第一次加载，对静态域进行初始化，因此staticVarOneInB(4)，staticvarTwoInB(5)被初始化。
• 之后顺序初始化varOneInB(6)，varTwoInB(7)，执行构造器B(8)。
• 在A静态域初始化后，回到main()方法，打印出了“start running”(9),在new A()(10)的时候，分配a对象的空间，开始顺序初始化varOneInA(11)，varTwoInA(12)和b(13)，初始化b的时候因为不是第一次加载，所以staticVarOneInB，staticvarTwoInB不再被初始化，只是初始化了varOneInB(14)，varTwoInB(15)，然后执行构造B(16)。
• 初始化完成后，调用A的构造器(17)；最后通过a.run()调用run(18)方法，打印出“run be called”。

具有继承的类的初始化

  下面，我创建了一个Father类和一个继承Father类的Son类，来探究在有继承的时候类的初始化和加载，情况基本和上面类似，我就不再写太多的注释了。Father类如下：

public class Father {    private int varInFather = initInt("varInFather");    private static int staticVarInFather = initInt("staticVarInFather");    public Father(String name) {        System.out.println("Father constructor" + " name:" + name);    }    private static int initInt(String varName) {        System.out.println(varName + " init");        return 2017;    }}

Son.java如下：

public class Son extends Father{    private int varInSon = initInt("varInSon");    private static int staticVarInSon = initInt("staticVarInSon");    public Son(String name) {        super(name);        System.out.println("Son constructor" + " name:" + name);    }    private static int initInt(String varName) {        System.out.println(varName + " init");        return 2017;    }    public static void main(String[] args) {        System.out.println("start running");        Son son = new Son("Bob");    }}

输出结果如下；

staticVarInFather initstaticVarInSon initstart runningvarInFather initFather constructor name:BobvarInSon initSon constructor name:Bob

  同样的，我将《Think in java》中的关于继承的类加载和初始化归纳如下：

注意：即使变量定义散布于方法定义之间，它们仍旧会在任何方法（包括构造器）被调用之前得到初始化。

1. （同上）即使没有显示地使用static关键字，构造器实际上也是静态方法。因此，当首次创建类的对象时（构造器可以看出静态方法），或者类的静态方法/静态域被首次访问时，Java解释器必须查找类路径，在对它进行加载的过程中，编译器注意到它有一个基类（有extends得知），于是它继续加载，不管你时候打算产生一个该基类的对象。如果该基类还有其自身的基类，那么第二个基类就会被加载，如此类推。
2. 接下来，根基类的static初始化会被执行，然后是下一个导出类，如此类推。
3. 必要的类加载完成后，对象就可以被创建。同样的，首先对象中所有的基本类型都会被设为默认值，对象引用被设为null——通过将对象内存设为二进制零值而一举生成。
4. 然后基类的构造器会被调用。基类构造器和导出类的构造器一样，以相同的顺序来经历相同的过程。
5. 在基类构造器完成之后，实例变量按其次序被初始化。
6. 最后，构造器的其余部分被执行。

  在有了上述归纳后，我们来分析上面程序的结果。

• 在类Son中执行main方法，由于main()是静态方法，必须加载Son类，在加载的时候发现其有父类Father，进而加载Father类。
• Father类被加载的时候，其静态变量staticVarInFather被初始化，之后Son类中的静态变量staticVarInSon被初始化。
• 回到main方法，打印出“start running”
• 在执行new Son("Bob")的时候，对基类也就是Father中的varInFather进行初始化，之后Father的构造器被调用。
• 之后导出类变量varInSon被初始化，调用导出类Son的构造器。

具有继承的静态内部类

  关于这个的讲解，我引用一道2015携程Java工程师笔试题。来自csdb博客fuck两点水的 2015携程JAVA工程师笔试题(基础却又没多少人做对的面向对象面试题)。题目如下：

public class Base{    private String baseName = "base";    public Base()    {        callName();    }    public void callName()    {        System. out. println(baseName);    }    static class Sub extends Base    {        private String baseName = "sub";        public void callName()        {            System. out. println (baseName) ;        }    }    public static void main(String[] args)    {        Base b = new Sub();    }}

  当时看到这道题的时候，关于类的加载，初始化基本已经忘记，所以直接做错。该题的正确答案是：

null

为什么是null?首先我们从上面的内容可以了解到，类的初始化顺序是：

父类静态块 ->子类静态块 ->父类初始化语句 ->父类构造函器 ->子类初始化语句 子类构造器。

其实在掌握了我上面说的东西后，这道题的的答案为什么为null,已经是“柳暗花明又一村了”；所以我这里直接把fuck两点水博客上的内容摘抄过来

1. Base b = new Sub();在 main方法中声明父类变量b对子类的引用，JAVA类加载器将Base,Sub类加载到JVM;也就是完成了 Base 类和 Sub 类的初始化
2. JVM 为 Base,Sub 的的成员开辟内存空间且值均为null;在初始化Sub对象前，首先JAVA虚拟机就在堆区开辟内存并将子类 Sub 中的 baseName 和父类 Base 中的 baseName（已被隐藏）均赋为 null，就是子类继承父类的时候，同名的属性不会覆盖父类，只是会将父类的同名属性隐藏
3. 调用父类的无参构造调用 Sub 的构造函数，因为子类没有重写构造函数，默认调用无参的构造函数，调用了 super() 。
4. callName 在子类中被重写，因此调用子类的 callName();调用了父类的构造函数，父类的构造函数中调用了 callName 方法，此时父类中的 baseName 的值为 base，可是子类重写了 callName 方法，且 调用父类 Base 中的 callName 是在子类 Sub 中调用的，因此当前的 this 指向的是子类，也就是说是实现子类的 callName 方法
5. 调用子类的callName，打印baseName

实际上在new Sub()时，实际执行过程为：

public Sub(){    super();    baseName = "sub"; }

可见，在 baseName = “sub” 执行前，子类的 callName() 已经执行，所以子类的 baseName 为默认值状态 null 。
  上面的题，大家可以试着把子类中的baseName使用static进行修饰，看看会得到什么结果，加深自己的理解。
  关于类的加载和初始化的备忘录就到此结束了。