java初始化顺序

今天想看一下java编程思想，心血来潮看看上一节的课后题，就是9.1章的练习3的那道题，题目是这样的：
创建一个基类，让它包含抽象方法print()，并在导出类中覆盖该方法。覆盖后的方法版本可以打印导出类中定义的某个整形变量的值。在定义该变量处，赋予它非零的值。在基类的构造器中调用这个方法。现在，在main()方法中，创建一个导出类对象，然后调用它的print()方法。请解释发生的情形
可以直接看代码

class Father{
    public Father(){
        print();
    }
    public void print(){
    }
}
class Child extends Father{
    public int age = 1;
    public void print(){
        System.out.println("child age = " + age);
    }
}
public class Main{
    public static void main(String[] args){
        Child c = new Child();
        c.print();
    }
}

输出结果：

child age = 0
child age = 1

我能够想到的是
1. 先在堆上分配一块区域给对象，然后将这块区域初始化为0
2. 父类普通成员初始化
3. 执行父类构造函数
4. 子类普通成员初始化
5. 执行子类构造函数
我认为结果应该是只有 child age = 1 这一条语句，但是不知道为什么父类中调用print()函数，会执行子类中的print()，多态在这里也能用吗？子类还没有被构造完呀！ 问了一下确实是多态，以后在系统学习一下jvm再回头看这个问题吧。。

也学习了一些初始化的知识，记录分享一下
java类初始化包括 静态成员变量初始化、静态代码块初始化、普通成员变量初始化、普通代码块初始化和构造函数中的初始化。 写了一段代码，应该可以解决顺序问题(英语很挫)：

class Msg{
    public Msg(String msg){
        System.out.println(msg);
    }
}
class Father{
    public static Msg fsm = new Msg("father static member init");

    static {
        fsm = new Msg("father static code block init");
    }

    public Msg fnm = new Msg("father normal member init");

    {
        fnm = new Msg("father normal code block init");
    }

    public Father(){
        System.out.println("father constructor");
    }
}

class Child extends Father{
    public static Msg fsm = new Msg("child static member init");

    static {
        fsm = new Msg("child static code block init");
    }

    public Msg fnm = new Msg("child normal member init");

    {
        fnm = new Msg("child normal code block init");
    }


    public Child(){
        System.out.println("child constructor");
    }

}
public class ClassInitOrder{
    public static void main(String args[]){
        //Father f = new Child();
        Child.fsm = new Msg("test");
    }
}

输出结果

father static member init       //父类 静态成员变量初始化
father static code block init   //父类 静态代码块初始化
child static member init        //子类 静态成员变量初始化
child static code block init    //子类 静态代码块初始化
father normal member init       //父类 普通成员变量初始化
father normal code block init   //父类 构造代码块初始化
father constructor              //父类 构造函数
child normal member init        //子类 普通成员变量初始化
child normal code block init    //子类 构造代码块初始化
child constructor               //子类 构造函数

有继承关系的初始化顺序就是这样，我感觉一个对象被分配出来可以简单分为两个步骤：
1. 类初始化
这个过程就是静态成员变量的初始化，包括静态成员变量初始化和静态代码块初始化。当创建这个类的一个对象的或者使用这个类的静态方法和变量的时候会进行。比如上面的代码main函数变一下

public class ClassInitOrder{
    public static void main(String args[]){
        //Father f = new Child();
        Child.fsm = new Msg("test");
    }
}

结果是这样：

test
father static member init
father static code block init
child static member init
child static code block init

结果只初始化了父类和子类的静态部分

2.对象初始化
这个过程包括 普通成员变量初始化、构造代码块初始化和构造函数中的初始化。这个过程只有创建一个类的对象是才会进行。