Java 的子-父类的 static 代码块、non-static 代码块、构造器及成员变量初始化的执行顺序

本部主要介绍内容：Java 在加载时，static 代码块执行顺序；创建实例对象时，non-static 代码块、子-父类构造器和成员变量初始化的执行顺序。
执行顺序（子类继承父类）：静态代码块 --》默认初始化 --》父类构造方法 --》显示初始化 --》非静态代码块 --》子类构造方法
执行顺序（单一类，默认不考虑 Object 类）：静态代码块 --》成员变量默认初始化 --》 成员变量显示初始化 --》 非静态代码块 --》构造器

总结

1. Java 类在加载时，就是执行静态代码块，加载完成；成员变量默认初始化；接着成员变量显示初始化；非静态代码块执行；构造器执行
2. Java 一个类只会加载一次到 JVM（Java 虚拟机） 内存，所以静态代码块只会执行一次

static 代码块

1. 在类加载内存时，执行代码。只会执行一次（因为类只会加载一次），以后无论创建多少实例对象都不会在执行

// static 代码块
static {
      System.out.println("static-code-part of parent");
  }

构造器

1. 创建实例对象时，先会调用本类的构造方法。
2. 当子类继承父类时，创建子类实例对象，会先调用子类构造器，但子类构造器第一行是隐式 super() ，隐式调用父类无参构造器（当然也可以自定义调用父类的各种构造器），所以会去执行父类的构造器

// 子类构造器，隐式调用父类无参构造器
Sub() {
      // super() // 隐式调用父类无参构造器
      System.out.println("Sub " + num);
  }

non-static 代码块

1. 在创建实例时，执行代码。每创建一个实例对象，就执行一次

// non-static 代码块
{
      System.out.println("code-part of parent " + num);
      num = 9;
  }

成员变量的初始化过程

1. 成员变量初始化分为 2 步：
   说明：成员变量的 2 步初始化都是在创建实列对象时进行的操作
   • 第一步：称为默认初始化，int 类型默认初始化为 0、Boolean 类型默认初始化为false ...
   • 此步，在静态代码块执行之后，父类构造方法之前执行

     // 成员变量
      int num = 9 // 在创建对象时，先进行的操作为 num = 0
     

   • 第二部：称为显示初始化，即对成员变量的赋值操作
   • 此步，在非静态代码块之前，在父类构造方法之后

     // 成员变量
     int num = 9 // 在创建对象时，默认初始化完成，再进行赋值操作 num = 9
     

实例验证

1. 创建子类
   • 成员变量、静态代码块、非静态代码块、构造器、普通方法
2. 创建父类
   • 成员变量、静态代码块、非静态代码块、构造器、普通方法
3. 注意
   • 静态绑定：通俗讲在编译时期确定，静态方法、静态和非静态成员变量、构造器、方法作用域
   • 动态绑定：通俗讲在执行时期确定，只有普通方法，所以只用普通方法存在多态
4. 验证

• 代码

  // 测试类
  class Model1 {
    public static void main(String[] args) {
         System.out.println("hello world");
         System.out.println("---------------------------");
  
         new Sub();
         System.out.println("---------------------------");
         new Sub();
    }
  }
  // 父类
  class P {
    int num = 2;
    // 构造器
    P() {
        // super(); 隐式调用 Object 的构造器
        System.out.println("Parent " + num);
        show();
    }
    // 普通方法
    void show() {
        System.out.println("con-Parent " + num);
    }
    // 非静态代码块
    {
        System.out.println("code-part of parent " + num);
        num = 9;
    }
    // 静态代码块
    static {
        System.out.println("static-code-part of parent");
    }
  }
  // 子类
  class Sub extends P {
    int num = 3;
    // 子类构造器
    Sub() {
        // super(); // 隐式调用 P 构造器 
        System.out.println("Sub " + num);
    }
    // 普通方法
    void show() {
        System.out.println("con-Sub " + num);
    }
    // 非静态代码块
    {
        System.out.println("code-part of sub " + num);
        num = 4;
    }
    // 静态代码块
    static {
        System.out.println("static-code-part of sub");
    }
  }
  

• 执行结果

  hello world
   ---------------------------
  static-code-part of parent  // 1. 父类加载时，执行静态代码块
  static-code-part of sub     // 2. 子类加载时，执行静态代码块
  code-part of parent 2       // 3. 创建子类实例对象时，执行父类非静态代码块
  Parent 9                    // 4. 执行父类构造器(父类对象成员变量已完成 2 步初始化)
  con-Sub 0                   // 5. 这是父类构造器调用 show() 函数(子类重写，即用的是子类的 show()，固成员变量也是子类的)，此时子类成员变量，只完成默认初始化
  code-part of sub 3          // 6. 父类构造器执行完成，子类成员变量完成显示初始化，子类的非静态代码块执行
  Sub 4                       // 7. 真正的子类构造器执行
  
  --------------------------- // 8. 再次创建对象，静态代码块不会执行了
  code-part of parent 2
  Parent 9
  con-Sub 0
  code-part of sub 3
  Sub 4