Java 中的继承和多态（深入版）

灰太狼 2021-08-27 22:09 250阅读 0赞

![format_png][]

面向对象的三大特性：封装、继承、多态。在这三个特性中，如果没有封装和继承，也不会有多态。

那么多态实现的途径和必要条件是什么呢？以及**多态中的重写和重载在JVM中的表现**是怎么样？在Java中是如何展现继承的特性呢？对于子类继承于父类时，又有什么限制呢？本文系基础，深入浅出过一遍 Java 中的多态和继承。

**多态**

*多态是同一个行为具有多个不同表现形式或形态的能力。*

举个栗子，一只鸡可以做成白切鸡、豉油鸡、吊烧鸡、茶油鸡、盐焗鸡、葱油鸡、手撕鸡、清蒸鸡、叫花鸡、啤酒鸡、口水鸡、香菇滑鸡、盐水鸡、啫啫滑鸡、鸡公煲等等。

**多态实现的必要条件**

用上面的“鸡的十八种吃法“来举个栗子。

首先，我们先给出一只鸡：

class Chicken{
        public void live(){
            System.out.println("这是一只鸡");
        }
    }

#### ***1.*** 子类必须继承父类 ####

对于子类必须继承父类，小编个人认为，是因为按照面向对象的五大基本原则所说的中的依赖倒置原则：**抽象不依赖于具体，具体依赖于抽象**。既然要实现多态，那么必定有一个作为"抽象"类来定义“行为”，以及若干个作为"具体"类来呈现不同的行为形式或形态。

所以我们给出的一个具体类——白切鸡类：

class BaiqieChicken extends Chicken{ }

但仅是定义一个白切鸡类是不够的，因为在此我们只能做到复用父类的属性和行为，而**没有呈现出行为上的不同的形式或形态**。

#### ***2.*** 必须有重写 ####

重写，简单地理解就是**重新定义的父类方法，使得父类和子类对同一行为的表现形式各不相同**。我们用白切鸡类来举个栗子。

class BaiqieChicken extends Chicken{
        public void live(){
            System.out.println("这是一只会被做成白切鸡的鸡");
        }
    }

这样就实现了重写，鸡类跟白切鸡类在live()方法中定义的行为不同，鸡类是一只命运有着无限可能的鸡，而白切鸡类的命运就是做成一只白切鸡。

但是为什么还要有“父类引用指向子类对象”这个条件呢？

#### ***3.*** 父类引用指向子类对象 ####

其实这个条件是面向对象的五大基本原则里面的里氏替换原则，简单说就是父类可以引用子类，但不能反过来。

当一只鸡被选择做白切鸡的时候，它的命运就不是它能掌控的。

Chicken c = new BaiqieChicken();
    c.live();

运行结果：

这是一只会被做成白切鸡的鸡

为什么要有这个原则？因为父类对于子类来说，是属于“抽象”的层面，子类是“具体”的层面。“抽象”可以提供接口给“具体”实现，但是“具体”凭什么来引用“抽象”呢？而且“子类引用指向父类对象”是不符合“依赖倒置原则”的。

当一只白切鸡想回头重新选择自己的命运，抱歉，它已经在锅里，逃不出去了。

BaiqieChicken bc = new Chicken();
    bc.live();

## **多态的实现途径** ##

多态的实现途径有三种：重写、重载、接口实现，虽然它们的实现方式不一样，但是核心都是：**同一行为的不同表现形式**。

### ***1.*** 重写 ###

重写，指的是子类对父类方法的重新定义，但是子类方法的参数列表和返回值类型，必须与父类方法一致！所以可以简单的理解，重写就是子类对父类方法的核心进行重新定义。

举个栗子：

class Chicken{
        public void live(String lastword){
            System.out.println(lastword);
        }
    }
    class BaiqieChicken extends Chicken{
        public void live(String lastword){
            System.out.println("这只白切鸡说：");
            System.out.println(lastword);
        }
    }

这里白切鸡类重写了鸡类的live()方法，为什么说是重写呢？因为白切鸡类中live()方法的参数列表和返回值与父类一样，但方法体不一样了。

### ***2. ***重载 ###

重载，指的是在一个类中有若干个**方法名相同，但参数列表不同的情况，返回值可以相同也可以不同**的方法定义场景。也可以简单理解成，同一行为（方法）的不同表现形式。

举个栗子：

class BaiqieChicken extends Chicken{
        public void live(){
            System.out.println("这是一只会被做成白切鸡的鸡");
        }
        public void live(String lastword){
            System.out.println("这只白切鸡说：");
            System.out.println(lastword);
        }
    }

这里的白切鸡类中的两个live()方法，一个无参一个有参，它们对于白切鸡类的live()方法的描述各不相同，但它们的方法名都是live。通俗讲，它们对于白切鸡鸡生的表现形式不同。

### ***3.*** 接口实现 ###

接口，是一种无法被实例化，但可以被实现的抽象类型，是抽象方法的集合，多用作定义方法集合，而方法的具体实现则交给继承接口的具体类来定义。所以，**接口定义方法，方法的实现在继承接口的具体类中定义，也是对同一行为的不同表现形式**。

interface Chicken{
        public void live();
    }
    class BaiqieChicken implements Chicken{
        public void live(){
            System.out.println("这是一只会被做成白切鸡的鸡");
        }
    }
    class ShousiChicken implements Chicken{
        public void live(){
            System.out.println("这是一只会被做成手撕鸡的鸡");
        }
    }

从上面我们可以看到，对于鸡接口中的live()方法，白切鸡类和手撕鸡类都有自己对这个方法的独特的定义。

## **在虚拟机中多态如何表现** ##

前文我们知道，java文件在经过javac编译后，生成class文件之后在JVM中再进行编译后生成对应平台的机器码。而JVM的编译过程中体现多态的过程，在于选择出正确的方法执行，这一过程称为**方法调用**。

**方法调用的唯一任务是确定被调用方法的版本**，暂时还不涉及方法内部的具体运行过程。（注：方法调用不等于方法执行）

在介绍多态的重载和重写在JVM的实现之前，我们先简单了解JVM提供的5条方法调用字节码指令：

> invokestatic：调用静态方法。  
> invokespecial：调用实例构造器方法、私有方法和父类方法。  
> invokevirtual：调用所有的虚方法（这里的虚方法泛指除了invokestatic、invokespecial指令调用的方法，以及final方法）。  
> invokeinterface：调用接口方法，会在运行时再确定一个实现此接口的对象。  
> invokedynamic：先在运行时动态解析出调用点限定符所应用的方法（说人话就是用于动态指定运行的方法）。

而方法调用过程中，在编译期就能确定下来调用方法版本的**静态方法、实例构造器方法、私有方法、父类方法和final方法**（虽是由invokevirtual指令调用）在编译期就已经完成了运行方法版本的确定，这是一个静态的过程，也称为**解析调用**。

而**分派调用**则有可能是静态的也可能是动态的，可能会在编译期发生或者运行期才确定运行方法的版本。

而分派调用的过程与多态的实现有着紧密联系，所以我们先了解一下两个概念：

> 静态分派：所有依赖静态类型来定位方法执行版本的分派动作。  
> 动态分派：根据运行期实际类型来定位方法执行版本的分派动作。

### ***1.*** 重载 ###

我们先看看这个例子：

public class StaticDispatch {
        static abstract class Human{ }
        static class Man extends Human{}
        static class Woman extends Human{}
        
        public void sayHello(Human guy){
            System.out.println("hello, guy!");
        }
        public void sayHello(Man guy){
            System.out.println("hello, gentleman!");
        }
        public void sayHello(Woman guy){
            System.out.println("hello, lady!");
        }
    
        public static void main(String[] args){
            Human man = new Man();
            Human woman = new Woman();
            StaticDispatch sr = new StaticDispatch();
            sr.sayHello(man);
            sr.sayHello(woman);
        }
    }

想想以上代码的运行结果是什么？3，2，1，运行结果如下：

hello, guy!
    hello, guy!

为什么会出现这样的结果？让我们来看这行代码：

Human man = new Man();

根据里氏替换原则，子类必须能够替换其基类，也就是说子类相对于父类是“具体类”，而父类是处于“奠定”子类的基本功能的地位。

所以，我们把上面代码中的“Human”称为变量man的**静态类型**（Static Type），而后面的"Man"称为变量的**实际类型**（Actual Type），二者的区别在于，**静态类型是在编译期可知的；而实际类型的结果在运行期才能确定**，编译期在编译程序时并不知道一个对象的实际类型是什么。

在了解了这两个概念之后，我们来看看字节码文件是怎么说的：

javac -verbose StaticDispatch.class

![format_png 1][]

我们看到，图中的黄色框的invokespecial指令以及标签，我们可以知道这三个是指令是在调用实例构造器方法。同理，下面两个红色框的invokevirtual指令告诉我们，这里是采用分派调用的调用虚方法，而且入参都是“Human”。

因为在分派调用的时候，使用哪个重载版本完全取决于传入参数的数量和数据类型。而且，**虚拟机（准确说是编译期）在重载时是通过参数的静态类型而不是实际类型作为判断依据**，并且静态类型是编译期可知的。

所以，**在编译阶段，Javac编译期就会根据参数的静态类型决定使用哪个重载版本**。重载是静态分派的经典应用。

### ***2. ***重写 ###

我们还是用上面的例子：

public class StaticDispatch {
        static abstract class Human{
            protected abstract void sayHello();
        }
        static class Man extends Human{
            @Override
            protected void sayHello() {
                System.out.println("man say hello");
            }
        }
        static class Woman extends Human{
            @Override
            protected void sayHello() {
                System.out.println("woman say hello");
            }
        }
        public static void main(String[] args){
            Human man = new Man();
            Human woman = new Woman();
            man.sayHello();
            woman.sayHello();
        }
    }

其运行结果为：

man say hello
    woman say hello

相信你看到这里也会会心一笑，这一看就很明显嘛，重写是按照实际类型来选择方法调用的版本嘛。先别急，我们来看看它的字节码：

![format_png 2][]

嘶…这好像跟静态分派的字节码一样啊，但是从运行结果看，这两句指令最终执行的目方法并不相同啊，那原因就得从invokevirtual指令的多态查找过程开始找起。

我们来看看invokevirtual指令的运行时解析过程的步骤：

> 1.  找到操作数栈顶的第一个元素所指向的对象的**实际类型**，记作C。
> 2.  如果在在类型C中找到与常量中的描述符和简单名称都相符的方法，则进行访问权限校验，如果通过则返回这个方法的**直接引用**，查找过程结束；如果不通过，则返回java.lang.IllegalAccessError异常。
> 3.  否则，按照继承关系从下往上依次对**C的各个父类**进行第2步的搜索和验证过程。
> 4.  如果始终没有找到合适的方法，则抛出java.lang.AbstractMethodError异常。

我们可以看到，由于invokevirtual指令在执行的第一步就是**在运行期确定接收者的实际类型**，所以字节码中会出现invokevirtual指令把常量池中的类方法符号引用解析到了不同的直接引用上，这个就是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虚拟机》）

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

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

![format_png 3][]

1. 加载：虚拟机通过这个**类的全限定名**来获取这个**类的二进制字节流**，然后在字节流中提取出这个**类的结构数据**，并转换成**这个类在方法区（存储类结构）的运行时数据结构**；

2. 验证：先验证这**字节流**是否符合Class文件格式的规范，然后检查**这个类的其父类**中数据是否存在冲突（如这个类的父类是否继承被final修饰的类），接着对**这个类内的方法体**进行检查，如果都没问题了，那就把之前的**符号引用换成直接引用**；

3. 准备：为**类变量**（static修饰的变量）**分配内存**（方法区）并**设置类变量初始值**，而这里的初始值是指这个数据类型的零值，如int的初始值是0；

4. 解析：在Class文件加载过程中，会将Class文件中的标识方法、接口的常量放进常量池中，而这些常量对于虚拟机来说，就是**符号引用**。此阶段就是针对类、接口、字段等7类符号引用，**转换成直接指向目标的句柄——直接引用**。

5. 初始化：这阶段是**执行static代码块和类构造器**的过程，有小伙伴可能会疑惑类构造器不是默认static的吗？详情请看这个博客:

https://www.cnblogs.com/dolphin0520/p/10651845.html

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

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

**结语**

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

坚持写技术文章的确是一件不容易的事情。现在技术更新越来越快，但是依然想把基础再打牢一点。

**参考资料：**

Java多态性理解

https://www.cnblogs.com/jack204/archive/2012/10/29/2745150.html

从虚拟机指令执行的角度分析JAVA中多态的实现原理

https://www.cnblogs.com/hapjin/p/9248525.html

《深入理解Java虚拟机》

https://blog.csdn.net/wei\_zhi/article/details/52780026

--------------------

\-END-

**推****荐****阅****读**

***1. ***[如何降低程序员的工资？][Link 1]

***2. ***[编写 Spring MVC 的 14 个小技巧][Spring MVC _ 14]

***3.*** [技术大佬的呕心力作！][Link 2]

***4. ***[详述 Spring Data JPA 的那些事儿][Spring Data JPA]

![format_png 4][]

[format_png]: /images/20210730/29aef4c598664a1b813c6fedceeeb6d1.png
[format_png 1]: /images/20210730/fe720180120f4d8784730f3c6411cc1f.png
[format_png 2]: /images/20210730/8886351ab0a94d7c94a9d4049b216177.png
[format_png 3]: /images/20210730/4edfcb3fba4d4ae7bd18eb9150d8841c.png
[Link 1]: https://blog.csdn.net/qq_37217713/article/details/104832452
[Spring MVC _ 14]: https://blog.csdn.net/qq_37217713/article/details/104832453
[Link 2]: https://blog.csdn.net/qq_37217713/article/details/104810020
[Spring Data JPA]: https://blog.csdn.net/qq_37217713/article/details/104810021
[format_png 4]: /images/20210730/e8114c1a03584a0f97148a948c073e7e.png