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 init
staticvarTwoInA init
staticVarOneB init
staticvarTwoInB init
varOneInB init
varTwoInB init
B  constructor
start running
varOneInA init
varTwoInA init
varOneInB init
varTwoInB init
B  constructor
A  constructor
run 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 init
staticVarInSon init
start running
varInFather init
Father constructor name:Bob
varInSon init
Son 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进行修饰，看看会得到什么结果，加深自己的理解。
  关于类的加载和初始化的备忘录就到此结束了。