1. public class A {
    2.     private static String a = "父类静态变量";
    3.     static {
    4.         System.out.println(a);
    5.         a = "父类静态方法块";
    6.         System.out.println(a);
    7.     }
    8.     private String a1 = "父类实例成员变量";
    9.     {
    10.         System.out.println(a1);
    11.         a1 = "普通方法块";
    12.         System.out.println(a1);
    13.     }
    15.     public A() {
    16.         System.out.println("父类构造方法");
    17.     }
    18. }
    20. public class B extends A {
    21.     private static String b = "子类静态变量";
    22.     static {
    23.         System.out.println(b);
    24.         b = "子类静态方法块";
    25.         System.out.println(b);
    26.     }
    27.     private String b1 = "子类实例成员变量";
    28.     {
    29.         System.out.println(b1);
    30.         b1 = "子类方法块";
    31.         System.out.println(b1);
    32.     }
    33.     public B() {
    34.         super();
    35.         System.out.println("子类实例构造方法");
    37.     }
    39.     public static void main(String[] args) {
    40.         new B();
    41.         System.out.println("---------------------");
    42.         new B();
    43.     }
    44. }
    46. // output:
    47. // 父类静态变量
    48. // 父类静态方法块
    49. // 子类静态变量
    50. // 子类静态方法块
    51. // 父类实例成员变量
    52. // 普通方法块
    53. // 父类构造方法
    54. // 子类实例成员变量
    55. // 子类方法块
    56. // 子类实例构造方法
    57. // ---------------------
    58. // 父类实例成员变量
    59. // 普通方法块
    60. // 父类构造方法
    61. // 子类实例成员变量
    62. // 子类方法块
    63. // 子类实例构造方法

    由输出可以看出:

    • 由static修饰的变量或方法块早于实例变量或方法块的初始化
    • 父类实例初始化早于子类实例初始化，且普通方法块在对象每次初始化时都会执行

    参考: