Java的继承(深入版)

前言

前文我们了解了面向对象的三大特征:封装、继承、多态。

那么在Java中是如何展现继承的特性呢?对于子类继承于父类时,又有什么限制呢?

在此解答这些问题之后,我们再了解下类的加载过程,加深对继承的了解。

(若文章有不正之处,或难以理解的地方,请多多谅解,欢迎指正)

引入继承

假如我们有两个类:生物类、猫类。

生物类:

class Animal{
	private String name;
	public void setName(String name){
		this.name = name;
	}
	public String getName(){
		return this.name;
	} 
}

猫类:

class Cat{
	private String name;
    private String sound;
	public void setName(String name){
		this.name = name;
	}
    public void setSound(String sound){
        this.sound = sound;
    }
	public String getName(){
		return this.name;
	} 
    public String getSound(){
        return this.sound;
    }
}

我们知道,猫也是属于生物中的一种,生物有的属性和行为,猫按理来说也是有的。但此时没有继承的概念,那么代码就得不到复用,长期发展,代码冗余、维护困难且开发者的工作量也非常大。

继承的概念

继承就是子类继承父类的特征和行为,使得子类对象(实例)具有父类的实例域和方法,或子类从父类继承方法,使得子类具有父类相同的行为。

简单来说,子类能吸收父类已有的属性和行为。除此之外,子类还可以扩展自身功能。子类又被称为派生类,父类被称为超类。

在Java中,如果要实现继承的关系,可以使用如下语法:

class 子类 extends 父类{}

继承的基本实现

继承的基本实现如下:

class Animal{
	private String name;
	public void setName(String name){
		this.name = name;
	}
	public String getName(){
		return this.name;
	} 
}
class Cat extends Animal{}

public class Test{
    public static void main(String[] args){
        Cat cat = new Cat();
        cat.setName("猫");
        System.out.println(cat.getName());
    }
}

运行结果为:

我们可以看出,子类可以在不扩展操作的情况下,使用父类的属性和功能

子类扩充父类

继承的基本实现如下:

class Animal{
	private String name;
	public void setName(String name){
		this.name = name;
	}
	public String getName(){
		return this.name;
	} 
}
class Cat extends Animal{
    private String sound;
    public void setSound(String sound){
		this.sound = sound;
	}
	public String getSound(){
		return this.sound;
	} 
}

public class Test{
    public static void main(String[] args){
        Cat cat = new Cat();
        cat.setName("NYfor2020")
        cat.setSound("我不是你最爱的小甜甜了吗?");
        System.out.println(cat.getName()+":"+cat.getSound());
    }
}

运行结果为:

NYfor2020:我不是你最爱的小甜甜了吗?

我们可以看出,子类在父类的基础上进行了扩展,而且对于父类来说,子类定义的范围更为具体。也就是说,子类是将父类具体化的一种手段

总结一下,Java中的继承利用子类和父类的关系,可以实现代码复用,子类还可以根据需求扩展功能。

继承的限制

1. 子类只能继承一个父类

**为什么子类不能多继承?**举个栗子。

class ACat{
	public void mewo(){...}
}
class BCat{
	public void mewo(){...}
}
class CCat extends ACat, BCat{
	@Override
	public void mewo(){...?}  //提问:这里的mewo()是继承自哪个类?
}

虽说Java只支持单继承,但是不反对多层继承呀!

class ACat{}
class BCat extends ACat{}
class CCat extends BCat{}

这样,BCat就继承了ACat所有的方法,而CCat继承了ACat、BCat所有的方法,实际上CCat是ACat的子(孙)类,是BCat的子类。

总结一下,子类虽然不支持多重继承,只能单继承,但是可以多层继承

2. private修饰不可直接访问,final修饰不可修改

private修饰

对于子类来说,父类中用private修饰的属性对其隐藏的,但如果提供了这个变量的setter/getter接口,还是能够访问和修改这个变量的。

class ACat {
    private String sound = "meow";
    public String getSound() {
        return sound;
    }
    public void setSound(String sound) {
        this.sound = sound;
    }
}

class BCat extends ACat {
}

public class Test {
    public static void main(String[] args) {
        BCat b = new BCat();
        b.setSound("我不是你最爱的小甜甜了吗?");
        System.out.println(b.getSound());
    }
}
final修饰

父类已经定义好的final修饰变量(方法也一样),子类可以访问这个属性(或方法),但是不能对其进行更改

class ACat {
    final String sound = "你是我最爱的小甜甜";
    public String getSound() {
        return sound;
    }
    public void setSound(String sound){
        this.sound = sound;  //这句执行不了,会报错的
    }
}

class BCat extends ACat {
}

总结一下,用private修饰的变量可以通过getter/setter接口来操作,final修饰的变量就只能访问,不能更改

3. 实例化子类时默认先调用父类的构造方法

在实例化子类对象时,会调用父类的构造方法对属性进行初始化,之后再调用子类的构造方法。

class A {
    public A(){
        System.out.println("我不是你最爱的小甜甜了吗?");
    }
    public A(String q){
        System.out.println(q);
    }
}

class B extends A {
    public B(){
        System.out.println("你是个好姑娘");
    }
}

public class Test {
    public static void main(String[] args) {
        B b = new B();
    }
}

运行结果为:

我不是你最爱的小甜甜了吗?
你是个好姑娘

从结果我们可以知道,在实例化子类时,会默认先调用父类中无参构造方法,然后再调动子类的构造方法。

那么怎么调用父类带参的构造方法呢?只要在子类构造方法的第一行调用super()方法就好。

class A {
    public A(String q){
        System.out.println(q);
    }
}

class B extends A {
    public B(){
        super("我是你的小甜甜?");
        System.out.println("你是个好姑娘");
    }
}

public class Test {
    public static void main(String[] args) {
        B b = new B();
    }
}

运行结果为:

我是你的小甜甜?
你是个好姑娘

在子类实例化时,默认调用的是父类的无参构造方法,而如果没有父类无参构造方法,则子类必须通过super()来调用父类的有参构造方法,且super()方法必须在子类构造方法的首行

总结一下,Java继承中有三种继承限制,分别是子类只能单继承、父类中private修饰的变量不能显式访问和final修饰的变量不能改变,以及实例化子类必定会先调用父类的构造方法,之后才调用子类的构造方法。

类是怎么加载的?

(此处只是粗略介绍类加载的过程,想了解更多可参考《深入理解Java虚拟机》)

类加载过程包括三个大步骤:加载、连接、初始化

这三个步骤的开始时间仍然保持着固定的先后顺序,但是进行和完成的进度就不一定是这样的顺序了。
在这里插入图片描述

  1. 加载:虚拟机通过这个类的全限定名来获取这个类的二进制字节流,然后在字节流中提取出这个类的结构数据,并转换成这个类在方法区(存储类结构)的运行时数据结构
  2. 验证:先验证这字节流是否符合Class文件格式的规范,然后检查这个类的其父类中数据是否存在冲突(如这个类的父类是否继承被final修饰的类),接着对这个类内的方法体进行检查,如果都没问题了,那就把之前的符号引用换成直接引用
  3. 准备:为类变量(static修饰的变量)分配内存(方法区)并设置类变量初始值,而这里的初始值是指这个数据类型的零值,如int的初始值是0;
  4. 解析:在Class文件加载过程中,会将Class文件中的标识方法、接口的常量放进常量池中,而这些常量对于虚拟机来说,就是符号引用。此阶段就是针对类、接口、字段等7类符号引用,转换成直接指向目标的句柄——直接引用
  5. 初始化:这阶段是执行static代码块和类构造器的过程,有小伙伴可能会疑惑类构造器不是默认static的吗?详情请看这个博客:再议Java中的static关键字

总结一下,类加载的过程中,首先会对Class文件中的类提取并转换成运行时数据结构,然后对类的父类和这个类的数据信息进行检验之后,为类中的类变量分配内存并且设置初始值,接着将Class文件中与这个类有关的符号引用转换成直接引用,最后再执行类构造器。

而且我们可以从第二步看出,在加载类的时候,会先去检查这个类的父类的信息,然后再检查这个类的方法体,也就是说,在加载类的时候,会先去加载它的父类

结语

初学Java的时候知道这些概念,但只是浅尝而止。现在跟着Hollis大佬的《Java 工程师成神之路!》,重新回顾这些知识的时候,发现如果自己只是像以前一样片面了解,那岂不是没有成长?所以在写文章的过程中,尝试写得更加深入且尽量易懂。当然,本人水平有限,如有不正之处,欢迎指正。

参考资料:

Java 继承(extends)详解

本文已授权发布在微信公众号:Java后端。

评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值