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虚拟机》）

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

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

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

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

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

结语

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

PS：辅导小朋友作业真的太难了，绝对是因为爱，才辅导我小表弟一个小时的英语作业。

参考资料：

[Java 继承（extends）详解](

NYfor2020

发布了6 篇原创文章 · 获赞 0 · 访问量 158

私信关注