初始化流程：

    1. 堆中开辟空间，加载class文件；
    2. 类变量 & static块 的初始化；
    3. 实例变量 & 非static块 的初始化；
    4. 构造器。

    对象始化流程 - 图1

    • 注意：

    类变量会在类加载的连接_准备阶段进行默认初始化，类加载的初始化阶段进行显示初始化；
    实例变量在初始化时，如果没有赋值，系统会赋默认初始化值。

    • 示例一：
      1. class X {
      2.   Y b = new Y();
      3.   X() {
      4.       System.out.print("X");
      5.   }
      6. }
      7. class Y {
      8.   Y() {
      9.       System.out.print("Y");
      10.   }
      11. }
      12. class Z extends X {
      13.   Y y = new Y();
      14.   Z() {
      15.       System.out.print("Z");
      16.   }
      17.   public static void main(String[] args) {
      18.       new Z();     //结果是 YXYZ
      19.   }
      20. }
      这段代码的执行流程：
    1. 以main方法为程序执行入口；
    2. 创建Z对象；
    3. 由于Z 对象继承 X 对象，所以得先初始化 X 对象；
    4. X 对象成员变量初始化时又 创建了 Y对象，所以得先创建Y对象；
    5. Y 对象的构造方法中直接打印 “Y”，自此Y 对象初始化完毕；
    6. 执行 X 对象的构造方法， 打印 “X” ，自此X 对象初始化完毕；
    7. Z 的成员变量中 创建 Y 对象，初始化 Y 对象，打印 “Y”，Y对象初始化完毕；
    8. 执行 Z 的 构造方法，打印 “Z” ，自从Z 对象初始化完毕。程序结束！
    • 示例二：
      1. public class HelloA {
      2.   public HelloA() {
      3.       System.out.println("HelloA");
      4.   }
      5.   //构造语句块
      6.   {
      7.       System.out.println("I'm A class");
      8.   }
      9.   //静态语句块
      10.   static {
      11.       System.out.println("static A");
      12.   }
      13. }
      14. class HelloB extends HelloA {
      15.   public HelloB() {
      16.       System.out.println("HelloB");
      17.   }
      18.   {
      19.       System.out.println("I'm B class");
      20.   }
      21.   static {
      22.       System.out.println("static B");
      23.   }
      24.   public static void main(String[] args) {
      25.       new HelloB();
      26.   }
      27. }
      28. ===============控制台===============
      29. staticA
      30. staticB
      31. I'm A class
      32. HelloA
      33. I'm Bclass
      34. HelloB
      对象的初始化顺序：
    1. 类加载之后，按从上到下（从父类到子类）执行被static修饰的语句；
    2. 当static语句执行完之后,再执行main方法；
    3. 如果有语句new了自身的对象，将从上到下执行构造代码块、构造器（两者可以说绑定在一起）。