类、实例初始化

类初始化

先父类后子类

main方法所在的类需要先加载和初始化{

父类：{ 静态类变量显示赋值代码，静态代码块 按顺序执行 }

子类：{ 静态类变量显示赋值代码，静态代码块 按顺序执行 }

}

• 类初始化只有一次！

实例初始化

先父类后子类

父类： { 非静态类变量显示赋值代码，非静态代码块 按顺序执行，最后执行构造方法 }

这里需要注意的是，调用父类方法时，若子类已经重写了父类的方法，则谁调用（也就是实例化的是谁）执行谁的方法体

子类： { 非静态类变量显示赋值代码，非静态代码块 按顺序执行，最后执行构造方法 }

• 实例化几个对象就执行几次

代码：

Father.java

/**
  * 父类初始化<clinit>
  * 1、j = method()
  * 2、 父类的静态代码块
  *
  * 父类实例化方法:
  * 1、super()（最前）
  * 2、i = test() (9)
  * 3、子类的非静态代码块 (3)
  * 4、子类的无参构造（最后）(2)
  *
  *
  * 非静态方法前面其实有一个默认的对象this
  * this在构造器或<init> 他表示的是正在创建的对象，因为咱们这里是正在创建Son对象，所以
  * test()执行的就是子类重写的代码(面向对象多态)
  *
  * 这里i=test() 执行的就是子类重写的test()方法

  */
 public class Father {
     private int i = test();
     private static int j = method();
 ​
     static{
         System.out.println("(1)");
     }
     Father() {
         System.out.println("(2)");
     }
     {
         System.out.println("(3)");
     }
     public int test(){
         System.out.println("(4)");
         return 1;
     }
     public static int method() {
         System.out.println("(5)");
         return 1;
     }
 }

Son.java

/**
  * 子类的初始化<clinit>
  * 1、j = method()
  * 2、子类的静态代码块
  *
  * 先初始化父类 (5)(1)
  * 初始化子类 (10) (6)
  *
  * 子类实例化方法:
  * 1、super()（最前
  * 2、i = test() (9)
  * 3、子类的非静态代码块 (8)
  * 4、子类的无参构造（最后）(7)
  */
 public class Son extends Father {
     private int i = test();
     private static int j = method();
     static {
         System.out.println("(6)");
     }
     Son() {
         super();
         System.out.println("(7)");
     }
     {
         System.out.println("(8)");
     }
     public int test(){
         System.out.println("(9)");
         return 1;
     }
     public static int method() {
         System.out.println("(10)");
         return 1;
     }
 ​
     public static void main(String[] args) {
         Son son = new Son();
         System.out.println();
         Son son1 = new Son();
     }
 }

执行结果： 
 (5)
 (1)
 (10)
 (6)
 (9)
 (3)
 (2)
 (9)
 (8)
 (7)
 ​
 (9)
 (3)
 (2)
 (9)
 (8)
 (7)