java基础——类的初始化、实例化流程

父类

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;
    }

    private static int method() {

        System.out.println("(5)");
        return 1;
    }
}

子类

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 2;
    }

    private static int method() {

        System.out.println("(10)");
        return 2;
    }

    public static void main(String[] args) {
        Son son1 = new Son();

        System.out.println();

        Son son2 = new Son();
    }
}

写出父类和子类实例化过程的输出。

分析一波：

main被执行时：

一、类初始化
子类初始化<clinit>(由两部分构成 1，类变量显示赋值代码，2，静态代码块 （没有先后顺序，谁写在上面谁先执行）)

        1、j=method(); （static 变量） 
        2、子类的静态代码块

此时，应该先初始化父类   输出：(5) (1)  //父类类变量显示赋值代码写在静态代码块之上

再初始化子类  输出：（10） （6）

二、子类的实例初始化方法<init>
（1）super()  (最前)   //(9)(3)(2)  这部分是父类在执行
（2）i=test();  (9)
 (3)子类的非静态代码块    (8)
 (4）子类的无参构造器  （最后）   (7)

因为创建了两个 son对象  所以 子类实例初始化方法 <init> 被执行两次  932987

要想知道为什么是上面的结果，先看一下父类真实的加载顺序

父类初始化<clinit>(由两部分构成 1，类变量显示赋值代码，2，静态代码块 （没有先后顺序，谁写在上面谁先执行）)
     1、j=method();  (5) 
     2、父类静态代码块  (1)

     二、父类的的实例初始化方法
  * （1）super()  (最前)
  * （2）i=test; //此处，由于多态问题 执行的应该是 (9)
  *  3)父类的的非静态代码块  (3)
  *  4）父类的的无参构造器  (2)


  非静态方法前面其实有一个默认对象 this
  this在构造器(或<init>) 它表示的是正在创建的对象，因为是正在创建son对象，
  所以 test()执行的是子类重写的代码(面向对象 多态)

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

所以最终输出结果为

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

(9)(3)(2)(9)(8)(7)

本题的考点是

• 类的初始化过程
• 实例初始化过程
• 方法的重写

类的初始化过程：

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

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

（2）一个子类要初始化需要先初始化父类

（3）一个类初始化就是执行<clinit>()方法

• <clinit>()方法由静态类变量显示赋值代码和静态代码块组成
• 类变量显示赋值代码和静态代码块代码从上到下顺序执行
• <clinit>()方法只执行一次

<clinit>() class initializes 类初始化方法，系统自动赋予的，在字节码文件中 可以看见

由此可见，即使上述例子中，即使main中没有任何代码，最终输出结果也会是

5 1 10 6 因为，类的加载 是在对象实例化之前就已经完成的。

实例初始化过程

（1）实例初始化就是执行<init>0 方法

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

方法的重写（Override）

(1)哪些方法不可以被重写

• final方法
• 静态方法
• private等子类中不可见方法

(2)对象的多态性

• 子类如果重写了父类的方法，通过子类对象调用的一定是子类重写过的代码
• 非静态方法默认的调用对象是this
• this对象在构造器或者说<init>方法中就是正在创建的对象

此处，，我们顺便回顾一下Override 和Overload

Override的重写要求？

方法名

形参列表

参数列表必须完全与被重写的方法参数列表相同。

返回值类型

返回的类型必须与被重写的方法的返回类型相同 （Java1.5 版本之前返回值类型必须一样，之后的 Java 版本放宽了限制，返回值类型必须小于或者等于父类方法的返回值类型）

抛出的异常列表

重写方法一定不能抛出新的检査异常或者比被重写方法声明更加宽泛的检査型异常。 例如，父类的一个方法声明了一个检査异常 IOException，在重写这个方法时就不能抛出 Exception，只能拋出 IOException 的子类异常

修饰符

访问权限不能比父类中被重写方法的访问权限更低 （public>protected>default>private）

另外还要注意以下几条：

重写的方法可以使用 @Override 注解来标识。

父类的成员方法只能被它的子类重写。

声明为 final 的方法不能被重写 。

声明为 static 的方法不能被重写，但是能够再次声明。

构造方法不能被重写。

子类和父类在同一个包中时，子类可以重写父类的所有方法， 除了声明为 private 和 final 的方法。

子类和父类不在同一个包中时，子类只能重写父类的声明为 public 和 protected 的非 final 方法。 如果不能继承一个方法，则不能重写这个方法。