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
    

推荐阅读更多精彩内容