Java多态的实现机制——静态分派与动态分派

拼搏现实的明天。 2022-05-15 06:47 187阅读 0赞

# 1. Java多态简介 #

多态是同一个行为具有多个不同表现形式或形态的能力。 多态就是同一个接口，使用不同的实例而执行不同操作，如下图所示：

![dt-java.png][]

多态存在的三个必要条件：继承、重写、父类引用指向子类对象。

多态的体现：重写、接口、抽象类和抽象方法

多态性语言具有灵活，抽象，行为共享，代码共享的优势，很好的解决了应用程序函数同名问题。

更多介绍：[http://www.runoob.com/java/java-polymorphism.html][http_www.runoob.com_java_java-polymorphism.html]

# 2. 方法解析 #

Class 文件的编译过程中不包含传统编译中的连接步骤，一切方法调用在 Class 文件里面存储的都只是符号引用，而不是方法在实际运行时内存布局中的入口地址。这个特性给 Java 带来了更强大的动态扩展能力，使得可以在类运行期间才能确定某些目标方法的直接引用，称为**动态连接**，也有一部分方法的符号引用在类加载阶段或第一次使用时转化为直接引用，这种转化称为**静态解析**。

静态解析成立的前提是：方法在程序真正执行前就有一个可确定的调用版本，并且这个方法的调用版本在运行期是不可改变的。换句话说，调用目标在编译器进行编译时就必须确定下来，这类方法的调用称为解析。

在 Java 语言中，符合“编译期可知，运行期不可变”这个要求的方法主要有**静态方法**和**私有方法**两大类，前者与类型直接关联，后者在外部不可被访问，这两种方法都不可能通过继承或别的方式重写出其他的版本，因此它们都适合在类加载阶段进行解析。

Java 虚拟机里共提供了五条方法调用字节指令，分别是：

*  invokestatic：调用静态方法。
 *  invokespecial：调用实例构造器方法、私有方法和父类方法。
 *  invokevirtual：调用所有的虚方法。
 *  invokeinterface：调用接口方法，会在运行时再确定一个实现此接口的对象。
 *  invokedynamic：先在运行时动态解析出调用点限定符所引用的方法，然后再执行该方法，在此之前的4条调用指令，分派逻辑是固化在Java虚拟机内部的，而invokedynamic指令的分派逻辑是由用户所设定的引导方法决定的。

只要能被 invokestatic 和 invokespecial 指令调用的方法，都可以在解析阶段确定唯一的调用版本，符合这个条件的有静态方法、私有方法、实例构造器和父类方法四类，它们在类加载时就会把符号引用解析为该方法的直接引用。这些方法可以称为非虚方法（还包括 final 方法），与之相反，其他方法就称为虚方法（final 方法除外）。这里要特别说明下 final 方法，虽然调用 final 方法使用的是 invokevirtual 指令，但是由于它无法覆盖，没有其他版本，所以也无需对方发接收者进行多态选择。Java 语言规范中明确说明了 final 方法是一种非虚方法。

虚拟机栈中会存放当前方法调用的栈帧，在栈帧中，存储着局部变量表、操作栈、动态连接 、返回地址和其他附加信息。多态的实现过程，就是方法调用动态分派的过程，通过栈帧的信息去找到被调用方法的具体实现，然后使用这个具体实现的直接引用完成方法调用。

以 invokevirtual 指令为例，在执行时，大致可以分为以下几步：

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

可以看到，如果子类覆盖了父类的方法，则在多态调用中，动态绑定过程会首先确定实际类型是子类，从而先搜索到子类中的方法。这个过程便是方法覆盖的本质。

# 3. 方法的调用 #

## 3.1 解析调用 ##

**解析调用一定是个静态过程，在编译期间就完全确定，在类加载的解析阶段就会把涉及的符号引用转化为可确定的直接引用，不会延迟到运行期再去完成。**

## 3.2 分派调用 ##

分派调用则可能是静态的也可能是动态的，根据分派依据的**宗量数**（方法的调用者和方法的参数统称为方法的宗量）又可分为单分派和多分派。两类分派方式两两组合便构成了静态单分派、静态多分派、动态单分派、动态多分派四种分派情况。

### 3.2.1 静态分派 ###

所有依赖**静态类型**来定位方法执行版本的分派动作，都称为静态分派，静态分派的最典型应用就是多态性中的方法重载。静态分派发生在编译阶段，因此确定静态分配的动作实际上不是由虚拟机来执行的。下面通过一段方法重载的示例程序来更清晰地说明这种分派机制：

class Human {
    }
    
    class Man extends Human {
    }
    
    class Woman extends Human {
    }
    
    public class StaticPai {
    
        public void say(Human hum) {
            System.out.println("I am human");
        }
    
        public void say(Man hum) {
            System.out.println("I am man");
        }
    
        public void say(Woman hum) {
            System.out.println("I am woman");
        }
    
        public static void main(String[] args) {
            Human man = new Man();
            Human woman = new Woman();
            StaticPai sp = new StaticPai();
            sp.say(man);
            sp.say(woman);
        }
    }

上面代码的执行结果如下：

I am human
     I am human

以上结果的得出应该不难分析。在分析为什么会选择参数类型为 Human 的重载方法去执行之前，先看如下代码：

Human man = new Man（）;

我们把上面代码中的“Human”称为变量的静态类型，后面的“Man”称为变量的实际类型。静态类型和实际类型在程序中都可以发生一些变化，区别是静态类型的变化仅仅在使用时发生，变量本身的静态类型不会被改变，并且最终的静态类型是在编译期可知的，而实际类型变化的结果在运行期才可确定。

回到上面的代码分析中，在调用 say()方法时，方法的调用者（回忆上面关于宗量的定义，方法的调用者属于宗量）都为 sp 的前提下，使用哪个重载版本，完全取决于传入参数的数量和数据类型（方法的参数也是数据宗量）。代码中刻意定义了两个静态类型相同、实际类型不同的变量，可见编译器（不是虚拟机，因为如果是根据静态类型做出的判断，那么在编译期就确定了）在重载时是通过参数的静态类型而不是实际类型作为判定依据的。并且静态类型是编译期可知的，所以在编译阶段，javac 编译器就根据参数的静态类型决定使用哪个重载版本。这就是静态分派最典型的应用。

### 3.2.2 动态分派 ###

动态分派与多态性的另一个重要体现——方法覆写(重写)有着很紧密的关系。向上转型后调用子类覆写的方法便是一个很好地说明动态分派的例子。这种情况很常见，因此这里不再用示例程序进行分析。很显然，在判断执行父类中的方法还是子类中覆盖的方法时，如果用静态类型来判断，那么无论怎么进行向上转型，都只会调用父类中的方法，但实际情况是，根据对父类实例化的子类的不同，调用的是不同子类中覆写的方法，很明显，这里是要根据变量的实际类型来分派方法的执行版本的。而实际类型的确定需要在程序运行时才能确定下来，这种在运行期根据**实际类型**确定方法执行版本的分派过程称为动态分派。

### 3.2.3 单分派和多分派 ###

前面给出：方法的接收者与方法的参数统称为方法的宗量。单分派是根据一个宗量对目标方法进行选择，多分派是根据多于一个宗量对目标方法进行选择。

为了方便理解，下面给出一段示例代码：

class Eat{  
    }  
    
    class Drink{  
    }  
    
    class Father{  
        public void doSomething(Eat arg){  
            System.out.println("爸爸在吃饭");  
        }  
        public void doSomething(Drink arg){  
            System.out.println("爸爸在喝水");  
        }  
    }  
    
    class Child extends Father{  
        public void doSomething(Eat arg){  
            System.out.println("儿子在吃饭");  
        }  
        public void doSomething(Drink arg){  
            System.out.println("儿子在喝水");  
        }  
    }  
    
    public class SingleDoublePai{  
        public static void main(String[] args){  
            Father father = new Father();  
            Father child = new Child();  
            father.doSomething(new Eat());  
            child.doSomething(new Drink());  
        }  
    }

运行结果应该很容易预测到，如下：

爸爸在吃饭
    儿子在喝水

我们首先来看编译阶段编译器的选择过程，即静态分派过程。这时候选择目标方法的依据有两点：一是方法的接收者的静态类型是 Father 还是 Child，二是方法参数类型是 Eat 还是 Drink。因为是根据两个宗量进行选择，所以 Java 语言的静态分派属于多分派类型。

再来看运行阶段虚拟机的选择，即动态分派过程。由于编译期已经了确定了目标方法的参数类型（编译期根据参数的静态类型进行静态分派），因此唯一可以影响到虚拟机选择的因素只有此方法的接收者的实际类型是 Father 还是 Child。因为只有一个宗量作为选择依据，所以 Java 语言的动态分派属于单分派类型。

![20181229152859411][]

根据以上论证，我们可以总结如下：目前的 Java 语言（JDK1.8）是一门静态多分派、动态单分派的语言。

虚拟机具体在选择哪个方法执行时：

根据在编译成class字节码文件后就确定了执行哪个方法----解析 or 分派

根据在方法是否由字节码指令 invokevirtual 调用----解析 or 分派（分派调用是由 invokevirtual 指令执行的）

根据方法接收者的静态类型 和 实际类型 ---- 动态分派 or 静态分派

根据宗量个数来 确定具体执行哪个方法----多分派 or 单分派

# 参考 #

*  [JAVA方法调用中的解析与分派][JAVA]
 *  [http://www.runoob.com/java/java-polymorphism.html][http_www.runoob.com_java_java-polymorphism.html]
 *  [https://blog.csdn.net/sunxianghuang/article/details/52280002][https_blog.csdn.net_sunxianghuang_article_details_52280002]
 *  [Java方法调用过程（静态分派与动态分派）][Java]

[dt-java.png]: /images/20220515/0fb4a50bb9ac48c09ef6e38ad7ab05da.png
[http_www.runoob.com_java_java-polymorphism.html]: http://www.runoob.com/java/java-polymorphism.html
[20181229152859411]: /images/20220515/fad872c3c4ce4337ba47616ecf773679.png
[JAVA]: https://www.cnblogs.com/hapjin/p/9374269.html
[https_blog.csdn.net_sunxianghuang_article_details_52280002]: https://blog.csdn.net/sunxianghuang/article/details/52280002
[Java]: https://qinzhaokun.github.io/2017/08/01/Java%E6%96%B9%E6%B3%95%E8%B0%83%E7%94%A8%E8%BF%87%E7%A8%8B%EF%BC%88%E9%9D%99%E6%80%81%E5%88%86%E6%B4%BE%E4%B8%8E%E5%8A%A8%E6%80%81%E5%88%86%E6%B4%BE%EF%BC%89/