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》这本书里面的关于初始化顺序的总结进行归纳如下：
注意：即使变量定义散布于方法定义之间，它们仍旧会在任何方法（包括构造器）被调用之前得到初始化。
- 即使没有显示地使用static关键字，构造器实际上也是静态方法。因此，当首次创建类的对象时（构造器可以看出静态方法），或者类的静态方法/静态域被首次访问时，Java解释器必须查找类路径。
- 然后载入class，有关静态初始化的所有动作都会执行（所以静态初始化只在Class对象首次被加载的时候进行一次）。
- 当使用new创建对象的时候，首先将在堆上为对象分配足够的存储空间。
- 这块存储空间会被清零，这就自动将Dog对象中的所有基本类型数据都设置成了默认值（对数字来说就是0，对布尔类型和字符类型也相同），而引用就则被设置成了null。
- 执行出现于字段定义出的初始化动作。
- 执行构造器。
有了上面的知识点，再来看上面的结果。我用数字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》中的关于继承的类加载和初始化归纳如下：
注意：即使变量定义散布于方法定义之间，它们仍旧会在任何方法（包括构造器）被调用之前得到初始化。
- （同上）即使没有显示地使用static关键字，构造器实际上也是静态方法。因此，当首次创建类的对象时（构造器可以看出静态方法），或者类的静态方法/静态域被首次访问时，Java解释器必须查找类路径，在对它进行加载的过程中，编译器注意到它有一个基类（有extends得知），于是它继续加载，不管你时候打算产生一个该基类的对象。如果该基类还有其自身的基类，那么第二个基类就会被加载，如此类推。
- 接下来，根基类的static初始化会被执行，然后是下一个导出类，如此类推。
- 必要的类加载完成后，对象就可以被创建。同样的，首先对象中所有的基本类型都会被设为默认值，对象引用被设为null——通过将对象内存设为二进制零值而一举生成。
- 然后基类的构造器会被调用。基类构造器和导出类的构造器一样，以相同的顺序来经历相同的过程。
- 在基类构造器完成之后，实例变量按其次序被初始化。
- 最后，构造器的其余部分被执行。
在有了上述归纳后，我们来分析上面程序的结果。
- 在类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两点水博客上的内容摘抄过来
- Base b = new Sub();在 main方法中声明父类变量b对子类的引用，JAVA类加载器将Base,Sub类加载到JVM;也就是完成了 Base 类和 Sub 类的初始化
- JVM 为 Base,Sub 的的成员开辟内存空间且值均为null;在初始化Sub对象前，首先JAVA虚拟机就在堆区开辟内存并将子类 Sub 中的 baseName 和父类 Base 中的 baseName（已被隐藏）均赋为 null，就是子类继承父类的时候，同名的属性不会覆盖父类，只是会将父类的同名属性隐藏
- 调用父类的无参构造调用 Sub 的构造函数，因为子类没有重写构造函数，默认调用无参的构造函数，调用了 super() 。
- callName 在子类中被重写，因此调用子类的 callName();调用了父类的构造函数，父类的构造函数中调用了 callName 方法，此时父类中的 baseName 的值为 base，可是子类重写了 callName 方法，且 调用父类 Base 中的 callName 是在子类 Sub 中调用的，因此当前的 this 指向的是子类，也就是说是实现子类的 callName 方法
- 调用子类的callName，打印baseName
实际上在new Sub()时，实际执行过程为：
public Sub(){
super();
baseName = "sub";
}
可见，在 baseName = “sub” 执行前，子类的 callName() 已经执行，所以子类的 baseName 为默认值状态 null 。
上面的题，大家可以试着把子类中的baseName使用static进行修饰，看看会得到什么结果，加深自己的理解。
关于类的加载和初始化的备忘录就到此结束了。
