3.1 题目

  1. package s01.e03;
  3. public class Father {
  4.     private int i = test();
  5.     private static int j = method();
  7.     static {
  8.         System.out.println("(1)");
  9.     }
  11.     Father() {
  12.         System.out.println("(2)");
  13.     }
  15.     {
  16.         System.out.println("(3)");
  17.     }
  19.     public int test() {
  20.         System.out.println("(4)");
  21.         return 1;
  22.     }
  24.     public static int method() {
  25.         System.out.println("(5)");
  26.         return 1;
  27.     }
  28. }
  1. package s01.e03;
  3. public class Son extends Father {
  4.     private int i = test();
  5.     private static int j = method();
  7.     static {
  8.         System.out.println("(6)");
  9.     }
  11.     Son() {
  12. //        super(); // 写或不写都在，在子类构造器中一定会调用父类的构造器
  13.         System.out.println("(7)");
  14.     }
  16.     {
  17.         System.out.println("(8)");
  18.     }
  20.     public int test() {
  21.         System.out.println("(9)");
  22.         return 1;
  23.     }
  25.     public static int method() {
  26.         System.out.println("(10)");
  27.         return 1;
  28.     }
  30.     public static void main(String[] args) {
  31.         Son s1 = new Son();
  32.         System.out.println();
  33.         Son s2 = new Son();
  34.     }
  35. }

image.png

3.2 考点

  • 类初始化过程
  • 实例初始化过程

  • 方法的重写

    3.3 类初始化过程

  • 一个类要创建实例需要先加载并初始化该类

    • main 方法所在的类需要先加载和初始化
  • 一个子类要初始化需要先初始化父类
  • 一个类初始化就是执行 () 方法
    • () 方法由静态类变量显式赋值代码和静态代码块组成
    • 类变量显式赋值代码和静态代码块代码从上到下顺序执行
    • () 方法只执行一次

      3.3.1 推算过程

      父类的初始化 ：
  1. j = method()
  2. 父类的静态代码块

子类的初始化 ：

  1. j = method()
  2. 子类的静态代码块

先初始化父类：(5)(1)
初始化子类：(10)(6)

3.4 实例初始化过程

  • 实例初始化就是执行 () 方法
  • () 方法可能重载有多个，有几个构造器就有几个 () 方法
  • () 方法由非静态实例变量显示赋值代码和非静态代码块、对应构造器代码组成
  • 非静态实例变量显示赋值代码和非静态代码块代码从上到下顺序执行，而对应构造器的代码最后执行
  • 每次创建实例对象，调用对应构造器，执行的就是对应的 () 方法
  • () 方法的首行是 super() 或 super(实参列表)，即对应父类的 () 方法

    3.4.1 推算过程

    子类的实例化方法：
  1. super()(最前) (9)(3)(2)
  2. i = test() (9)
  3. 子类的非静态代码块 (8)
  4. 子类的无参构造(最后) (7)

父类的实例化方法：

  1. super()(最前)
  2. i = test()
  3. 父类的非静态代码块
  4. 父类的无参构造(最后)

非静态方法前面其实有一个默认的对象 this，this 在构造器或 表示的是正在创建的对象，因为这里是在创建 Son 对象，所以 test() 执行的是子类重写的代码(面向对象多态)
这里 i=test() 执行的是子类重写的 test() 方法
因为创建了两个 Son 对象，因此实例化方法 执行两次 (9)(3)(2)(9)(8)(7)

3.5 方法的重写 Override

  • 哪些方法不可以被重写
    • final 方法
    • 静态方法
    • private 等子类中不可见方法
  • 对象的多态性
    • 子类如果重写了父类的方法，通过子类对象调用的一定是子类重写过的代码
    • 非静态方法默认的调用对象是 this
    • this 对象在构造器或者说 方法中就是正在创建的对象
  • Override 重写的要求
    • 方法名
    • 形参列表
    • 返回值类型
    • 抛出的异常列表
    • 修饰符