vcjmhg 的个人博客

自律者自由

  menu

关于java继承的哪些事 置顶!

引言

本文结合一个例子来说明继承实现的基本原理。

基类 Base 代码如下所示:

 1public class Base {
 2    public static int s;
 3    private int a;
 4    static {
 5        System.out.println("基类静态代码块,s:"+s);
 6        s=1;
 7    }
 8    {
 9        System.out.println("基类实例代码块,a:"+a);
10        a=1;
11    }
12    public Base(){
13        System.out.println("基类构造方法,a:"+a);
14        a=2;
15    }
16    protected void step(){
17        System.out.println("base s:"+s+",a:"+a);
18    }
19    public void action(){
20        System.out.println("start");
21        step();
22        System.out.println("end");
23    }
24}

注意: Base 包含一个静态变量 s,一个实例变量 a,一段静态初始化代码块,一段实例初始化代码块,一个构造方法,两个方法 step 和 action。

子类 Child 代码如下所示:

 1public class Child extends Base{
 2    public static int s;
 3    private int a;
 4    static {
 5        System.out.println("子类静态代码块,s:"+s);
 6        s=10;
 7    }
 8    {
 9        System.out.println("子类实例代码块,a:"+a);
10        a=10;
11    }
12    public Child(){
13        System.out.println("子类构造方法,a:"+a);
14        a=20;
15    }
16
17    @Override
18    protected void step() {
19        System.out.println("child s:"+s+",a:"+a);
20    }
21}

注意: 子类 Child 继承了 Base,也定义了和基类同名的静态变量 s 和实例变量 a 并且重写了方法 step。

测试的 main 方法代码如下所示:

 1public static void main(String[] args) {
 2    System.out.println("------------- new Child()");
 3    Child c=new Child();
 4    System.out.println("\n-- c.action");
 5    c.action();
 6    Base b=c;
 7    System.out.println("\n --- b.action()");
 8    System.out.println("\n --- b.s:"+b.s);
 9    System.out.println("\n --- c.s:"+c.s);
10    }

执行结果如下:

下边我们逐过程来解释下其背后发生了什么,并解释我们所提出的问题。

类的加载过程

在 Java 中,所谓的类加载指的是将类的相关信息加载到内存中。在 Java 中类是动态加载的,当第一次使用这个类的时候才会加载,而且在加载一个类的时候会查看其父类是否被加载,如果没有则会加载其父类。

一个类的信息主要包含以下几个部分:

类的加载过程顺序如下:

  1. 分配内存保存类的信息

  2. 给类变量赋默认值

    注意: 数字类变量默认值都是 0,boolean 默认值是 false,char 是 \u0000,引用型变量默认值都是 null

  3. 加载父类

  4. 设置父子关系

  5. 执行类的初始化代码

以我们的例子来说,我们这里有三份类信息,分别是 ChildBaseObject,内存布局如下图所示:

对象的创建过程

在类加载之后,new Child()就会创建 Child 对象,创建 Child 对象过程包括:

  1. 分配内存
  2. 对所有实例变量赋默认值
  3. 执行实例初始化代码

在该部分分配的内存包括本类和所有父类的实例变量,不包含任何静态变量(因为类加载过程中这部分变量的内存已经分配完成)。实例的初始化代码执行先从父类开始,父类执行完成之后再执行子类。但需要注意的是在任何类执行初始化代码之前,任何实例变量都会被赋默认值。

但需要注意的是,每一个对象除了保存类的实例变量之外,还保存着实际类信息的引用。

方法调用的过程

在该部分我们分析前边所提出的问题,首先我们先来看 c.action(),这句代码的执行过程如下:

  1. 查看 c 的对象类型,找到 Child 类型,在 Child 类中找 action 方法,发现没有然后到父类中寻找。
  2. 在父类 Base 中找到了方法 action,开始执行 action 方法;
  3. action 先输出 start,然后发现需要调用 step()方法,就从 Child 类型中去寻找 step()方法;
  4. 在 Child 类型中找到了 Child 方法,执行 Child 类中的 step()方法,输出 Child 类中的两个变量 s(=10),a(=20)的值;
  5. 继续执行 action 方法输出 end

在此处我们可以发现,寻找要执行的实例方法的时候,是从对象的实际类型信息开始查找的,找不到的时候在查找父类的类型信息

接着我们来看 b.action()的执行过程,这句话实际上输出的结果和 c.aciton()方法输出的结果是一样的,这我们称之为 动态绑定,而 动态绑定 实现的机制就是根据对象的实际类型信息查找要执行的方法,子类型中查找不到才会查找父类。这里因为 b 和 c 执行的是相同的对象,所有执行的结果是一样的。

而对于变量部分我们发现,其访问过程是 静态绑定 的,即无论对于类变量还是实例变量访问的时候,访问的实际变量都和其对象类的类型绑定,如 b.s 和 c.s 分别访问的是 Base.s 和 Child.s。例子中实例变量都是 private 类型的,如果是 public 我们会发现 b.a 访问的是 Base 类定义的实例变量 a,而 c.a 访问的是对象中 Child 类定义的实例变量 a。

小结

在该部分我们分析的类和对象加载的过程,以及在过程中方法和代码块的执行顺序,我们可以得到以下结论。

方法和代码的执行顺序:

  1. 父类的类初始化代码块(static 代码块)
  2. 子类的类代码初始化块
  3. 父类的实例初始化代码块
  4. 父类的构造方法
  5. 子类的实例初始化代码块
  6. 子类的构造方法

重载方法的执行逻辑:

寻找要执行的实例方法的时候,是从对象的实际类型信息开始查找的,找不到的时候在查找父类的类型信息。


标题:关于java继承的哪些事
作者:vcjmhg
地址:https://vcjmhg.top/what_happened_when_extend_in_java