JavaSE面试题05：类初始化和实例初始化

类初始化和实例初始化

题目

新建父类Father

/*
父类的初始化
*/
public class Father {
    private int i = test();
    private static int j = method();

    static {
        System.out.print("(1)");
    }

    Father() {
        System.out.print("(2)");
    }

    {
        System.out.print("(3)");
    }

    public int test() {
        System.out.print("(4)");
        return 1;
    }

    public static int method() {
        System.out.print("(5)");
        return 1;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

类Son继承Father

/*
初始化子类会先初始化父类
*/

public class Son extends Father {
    private int i =test();
    private static int j=method();
    static {
        System.out.print("(6)");
    }
    Son(){
        
//      super();  //写或不写，在子类构造器中一定会调用父类的构造器
        System.out.print("(7)");
    }
    {
        System.out.print("(8)");
    }
    public int test(){
        System.out.print("(9)");
        return 1;
    }
    public static int method(){
        System.out.print("(10)");
        return 1;
    }

    public static void main(String[] args) {
        Son son1 = new Son();
        System.out.println();
        Son son2 = new Son();
    }

}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34

考点

类初始化过程

1. 一个类要创建实例需要先加载并初始化该类
   • main方法所在的类要先初始化父类
2. 一个子类要初始化需要先初始化父类
3. 一个类初始化就是执行()方法
   • < init>()方法由静态变量显式赋值代码和静态代码块组成
   • 类变量显示赋值代码和静态代码块代码从上到下顺序执行
   • < init>>()方法只执行一次

实例初始化过程

1. 实例初始化就是执行< init>()方法

   • < init>()方法可能重载有多个，有几个构造器就有几个< init>方法
   • < init>()方法由静态实例变量显式赋值代码和非静态代码块、对应构造器代码组成

• 非静态实例变量显式赋值代码和非静态代码块代码从上到下执行顺序，而对应的代码块最后执行
  • < init>方法的首行是super()或super(实参列表)，即对应父类的< init>方法

方法的重写Override

• 那些方法不可以被重写？
  1. final
  2. 静态方法
  3. private等子类中不可见的方法
• 对象的多态性
  1. 子类如果重写了父类的方法，通过子类对象调用的一定是子类对象重写过的代码
  2. 非静态方法默认的调用对象sthis
  3. this对象在构造器或者说< init>方法中就是正在创建的对象

详解

类初始化的体现

• 如果main方法里面什么也不写，运行结果：

(5)(1)(10)(6)
1

解释：类初始化，先初始化父类，类初始化就是执行()方法，该方法由静态变量显式赋值和静态代码块组成，看其父类，静态代变量显式赋值有j，j=method();，method方法输出**（5），然后其静态代码块输出（1），其次是子类，静态变量显式赋值，j=method();，method方法输出（10），然后是静态代码块，输出（6），综上所述所以结果为(5)(1)(10)(6)**

• 如果main方法如题目所示，运行结果：

(5)(1)(10)(6)(9)(3)(2)(9)(8)(7)
(9)(3)(2)(9)(8)(7)
1
2

解释：

• 子类Son的实例化方法

  1. super()：（最前）
  2. i=test();（2和3按顺序执行）
  3. 子类的非静态代码块
  4. 子类的无参构造（最后）

• 父类类Father的实例化方法

  1. super()：（最前）
  2. i=test();（2和3按顺序执行）
  3. 父类的非静态代码块
  4. 父类的无参构造（最后）

• 非静态方法前面有一个默认的构造器this

  1. this在构造器（或< init>）它表示的是正在创建的对象，因为这里是在创建Son对象，所以test()执行的是子类重写的代码（面向对象多态）

     父类i=test()执行的是子类重写的test()方法

• 因为创建了两个Son对象，所以子类的实例初始化方法执行了两次

运行结果解释

实例化对象时，先执行子类的super(),所以为父类Father的实例化，父类不存在super的默认使用，所以先是i=test(),由因为上面解释了，父类i=test()执行的是子类重写的test()方法，所以先打印出**（9），然后是父类的非静态代码块，（3），然后是父类的无参构造器（2），子类调用玩super后向下执行，先是执行test方法打印出(9),然后是子类代码块（8），然后是子类的无参构造（7）**，

子类Son的实例化方法

1. super()：（最前） 932
2. i=test();**（2和3按顺序执行）**9
3. 子类的非静态代码块 8
4. 子类的无参构造（最后） 7

• 又因为创建了两个Son对象。所以实例化< init>方法执行了两次，所以又打印了一次932987，所以最终结果为：(5)(1)(10)(6)(9)(3)(2)(9)(8)(7)(9)(3)(2)(9)(8)(7)

知识点可参考文章

1. Java中关于方法的重写
2. Java子类对象实例化是什么意思？
3. Java关键字super
4. Java-面向对象的特征之二：继承
5. Java中类的成员之三：构造器(构造方法)
6. Java的static关键字