「Java 路线」| 方法调用的本质（含重载与重写区别）
点赞关注，再也不迷路，你的支持对我意义重大！前端
🔥 Hi，我是丑丑。本文 GitHub · Android-NoteBook 已收录，这里有 Android 进阶成长路线笔记 & 博客，欢迎跟着彭丑丑一块儿成长。（联系方式在 GitHub）java
前言
- 对于习惯使用面向对象开发的工程师们来讲，重载 & 重写 这两个概念应该不会陌生了。在中 / 低级别面试中，也经常会考察面试者对它们的理解（隐约记得当年在校招面试时遇到过）；
- 网上大多数资料 & 面经对这两个概念的阐述，多数仅停留在讨论二者在 表现上 的差别，让读者去被动地接受知识。在这篇文章里，我将更有深度地理解重载 & 重写的原理，应深刻理解Java 虚拟机执行引擎是如何进行方法调用的。请点赞，你的点赞和关注真的对我很是重要！
首先，尝试写出如下程序的输出：git
public class Base {
public static void funcStatic(String str){
System.out.println("Base - funcStatic - String");
}
public static void funcStatic(Object obj){
System.out.println("Base - funcStatic - Object");
}
public void func(String str){
System.out.println("Base - func - String");
}
public void func(Object obj){
System.out.println("Base - func - Object");
}
}
public class Child extends Base {
public static void funcStatic(String str){
System.out.println("Child - funcStatic - String");
}
public static void funcStatic(Object obj){
System.out.println("Child - funcStatic - Object");
}
@Override
public void func(String str){
System.out.println("Child - func - String");
}
@Override
public void func(Object obj){
System.out.println("Child - func - Object");
}
}
复制代码
public class Test{
public static void main(String[] args){
Object obj = new Object();
Object str = new String();
Base base = new Base();
Base child1 = new Child();
Child child2 = new Child();
base.funcStatic(obj); // 正常编程中不该该用实例去调用静态方法
child1.funcStatic(obj);
child2.funcStatic(obj);
base.func(str);
child1.func(str);
child2.func(str);
}
}
复制代码
程序输出：github
Base - funcStatic - Object
Base - funcStatic - Object
Child - funcStatic - Object
Base - func - Object
Child - func - Object
Child - func - Object
复制代码
程序输出是否与你的预期一致呢？遇到困难了吗，相信这篇文章必定能帮到你...面试
延伸文章
-
对于
Java编译过程不了解，请阅读：《Java | 聊一聊编译过程（编译前端 & 编译后端）》编程 -
对于
Class 文件 & 符号引用不了解，请阅读：《Java | 请概述一下 Class 文件的结构》后端 -
对于
类加载的流程不太了解，请阅读：《Java | 谈谈你对类加载过程的理解》markdown
目录
1. 静态类型 & 实际类型
每个变量都有两种类型：静态类型（Static Type） & 实际类型（Actual Type）。例以下面代码中，Base为变量base的静态类型，Child为实际类型：ide
Base base = new Child();
复制代码
二者的具体区别以下：函数
- 静态类型：引用变量的类型，在编译期肯定，没法改变
- 实际类型：实例对象的类型，在编译期没法肯定，需在运行期肯定，能够改变
这里先谈到这里，后文会从字节码的角度理解继续讨论两个类型。
2. 方法调用的本质
这一节，咱们来讨论Java中方法调用的本质。咱们知道，Java前端编译的产物是字节码，与C/C++不一样，前端编译过程当中并无连接步骤，字节码中全部的方法调用都是使用符号引用。举个例子：
- 源码：
public class Child extends Base {
@Override
void func() {
}
void test1(){
func();
}
void test2(){
super.func();
}
}
- 字节码（javap -c Child.class）：
Compiled from "Child.java"
public class com.Child extends com.Base {
// 构造函数，默认调用父类构造函数
public com.Child();
Code:
0: aload_0
1: invokespecial #1 // Method com/Base."<init>":()V
4: return
void func();
Code:
0: return
void test1();
Code:
0: aload_0
// invokevirtual 调用实例方法
1: invokevirtual #2 // Method func:()V
4: return
void test2();
Code:
0: aload_0
// invokespecial 调用静态方法
1: invokespecial #3 // Method com/Base.func:()V
4: return
}
复制代码
上面的字节码中，invokespecial和invokevirtual都是方法调用的字节码指令，具体细节下文会详细解释。后面的#1 #2 #3表示符号引用在常量池中的索引号，根据这个索引号检索常量表，能够查到最终表示的是一个字符串字面量，例如func:()V，这个就是方法的符号引用。
为了方便理解字节码，
javap反编译的字节码已经在注释中提示了最终表示的值，例如Method func:()V。
符号引用（Symbolic References）是一个用来无歧义地标识一个实体（例如方法/字段）的字符串，在运行期它会翻译为直接引用（Direct Reference）。对于方法来讲，就是方法的入口地址。
下图描述了方法符号引用的基本格式：
这个符号引用包含了变量的静态类型（若是是变量的静态类型与本类相同，不须要指明）、简单方法名以及描述符（参数顺序、参数类型和方法返回值）。经过这个符号引用，Java虚拟机就能够翻译出该方法的直接引用。可是，同一个符号引用，运行时翻译出来的直接引用多是不一样的，为何会这样呢？
- 小结：
1. 方法调用的本质是根据方法的符号引用肯定方法的直接引用（入口地址）
3. 从符号引用到直接引用
为何同一个符号引用，运行时翻译出来的直接引用多是不一样的？ 这与使用的方法调用指令的处理过程有关，Java字节码的方法调用指令一共有如下 5 种：
其中，根据调用方法的版本是否在编译期能够肯定，（注意：只是版本，而不是入口地址，入口地址只能在运行时肯定）能够将方法调用划分为静态解析 & 动态分派两种。
# 误区（重要）#
《深刻理解Java虚拟机》中将方法调用分为解析、静态分派、动态分派三种，又根据宗量的数量引入了静态多分派，动态单分派的概念。这些概念事实上过于字典化，也很容易让读者误认为静态分派与动态分派是非此即彼的互斥关系。事实上，一个方法能够同时重写与重载 ，重载 & 重写是方法调用的两个阶段，而不是两个种类。
下面，我将介绍Java中方法选择的三个步骤：
3.1 步骤1：生成符号引用（编译时）
上一节咱们提到过方法符号引用的基本格式，分为三个部分：
- 变量的静态类型：
类的全限定名中将.替换为/，例如java.lang.Object对应java/lang/Object
- 简单名称：
方法的名称，例如Object#toString()的简单名称为：toString
- 描述符：
方法的参数列表和返回值，例如Object#toString()的描述符为()LJava/lang/String;
描述符的规则不是本文重点，这里便再也不赘述了，若不了解可阅读延伸文章。这里咱们用两段程序验证上述规则，这两段程序中咱们考虑了重载 & 重写、静态 & 实例两个维度的因素：
程序一（重载 & 重写）
public class Base {
public void func() {}
public void func(int i){}
}
public class Child extends Base {
@Override
public void func() {}
@Override
public void func(int i){}
}
public class Test{
public static void main(String[] args){
Base base1 = new Base();
Base child1 = new Child();
Child child2 = new Child();
base1.func(); // invokevirtual com.Base.func:():V
child1.func(); // invokevirtual com.Base.func:():V
child2.func(); // invokevirtual com.Child.func:():V
base1.func(1); // invokevirtual com.Base.func:(I):V
child1.func(1); // invokevirtual com.Base.func:(I):V
child2.func(1); // invokevirtual com.Child.func:(I):V
}
}
复制代码
能够看到，符号引用中的类名确实是变量的静态类型，而不是变量的实际类型；方法名不用多说，方法描述符则选择重载方法中最合适的一个方法。这个例程很容易判断重载方法选择结果，具体选择规则其实更为复杂。
程序二（静态 & 实例）
public class Base {
public static void func() {}
public void func(int i){}
}
public class Child extends Base {
public static void func() {}
@Override
public void func(int i){}
}
public class Test{
public static void main(String[] args){
Base base1 = new Base();
Base child1 = new Child();
Child child2 = new Child();
符号引用与程序一相同，仅指令不一样
base1.func(); // invokestatic com.Base.func:():V
child1.func(); // invokestatic com.Base.func:():V
child2.func(); // invokestatic com.Child.func:():V
base1.func(1); // invokevirtual com.Base.func:(I):V
child1.func(1); // invokevirtual com.Base.func:(I):V
child2.func(1); // invokevirtual com.Child.func:(I):V
}
}
复制代码
能够看到，static对符号引用没有影响，仅影响使用的指令（静态方法调用使用invokestatic）。而经过对象实例去调用静态方法是javac的语法糖，编译时会转换为使用变量的静态类型固化到符号引用中。
- 小结：
1. 方法的符号引用在编译期肯定，并固化到字节码中方法调用指令的参数中
2. 是否有static修饰对符号引用没有影响，仅影响使用的字节码指令，对象实例去调用静态方法是javac的语法糖
3.2 步骤二：解析（类加载时）
为何静态方法、私有实例方法、实例构造器、父类方法以及final修饰这五种方法（对应的关键字： static、private、<init>、super、final）能够在编译期肯定版本呢？由于不管运行时加载多少个类，这些方法都保证惟一的版本：
| 方法 | 缘由 |
|---|---|
static |
相同签名的子类方法会隐藏父类方法 |
private |
只在本类可见 |
<init> |
由编译器生成，源码没法编写 |
super |
Java是单继承，只有一个父类 |
final |
禁止被重写 |
既然能够肯定方法的版本，虚拟机在处理invokestatic、invokespecial、invokevirtual(final)时，就能够提早将符号引用转换为直接引用，没必要延迟到方法调用时肯定，具体来讲，是在类加载的解析阶段完成转换的。
invokestatic 指令
-
1）类加载解析阶段：根据符号引用中类名（以下例中
java/lang/String变量的静态类型中），在对应的类中找到简单名称与描述符相符合的方法，若是找到则将符号引用转换为直接引用；不然，按照继承关系从下往上依次在各个父类中搜索 -
2）调用阶段：符号引用已经转换为直接引用；调用
invokestatic不须要将对象加载到操做数栈，只须要将所须要的参数入栈就能够执行invokestatic指令。例如：
源码：
String str = String.valueOf（"1"）
字节码：
0: iconst_1
1: invokestatic #2 // Method java/lang/String.valueOf:(I)Ljava/lang/String;
4: astore_1
复制代码
invokespecial 指令
-
1）类加载解析阶段：同
invokestatic，也是从符号引用中的静态类型开始查找 -
2）调用阶段：同
invokestatic，符号引用已经转换为直接引用；、父类方法、私有实例方法这3种状况都是属于实例方法，因此调用invokespecial指令须要将对象加载到操做数栈。例如：
一、源码（实例构造器）：
String str = new String();
字节码：
0: new #2 // class java/lang/String
3: dup
4: invokespecial #3 // Method java/lang/String."<init>":()V
7: astore_1
--------------------------------------------------------------------
二、源码（父类方法）：
super.func();
字节码：
0: aload_0
1: invokespecial #2 // Method com/Base.func:()V
--------------------------------------------------------------------
三、源码（私有方法）：
funcPrivate();
字节码：
0: aload_0
1: invokespecial #2 // Method funPrivate:()V
复制代码
3.3 步骤三：动态分派（类使用时）
动态分派分为invokevitrual、invokeinterface 与 invokedynamic，其中动态调用invokedynamic是 JDK 1.7 新增的指令，咱们单独在另外一篇中解析。有些同窗可能会以为方法不重写不就只有一个版本了吗？这个想法忽略了Java动态连接的特性，Java能够从任何途径加载一个class，除非解析的 5 种的状况外，没法保证方法不被重写。
invokevirtual指令
虚拟机为每一个类生成虚方法表vtable（virtual method table）的结构，类中声明的方法的入口地址会按固定顺序存放在虚方法表中；虚方法表还会继承父类的虚方法表，顺序与父类保持一致，子类新增的方法按顺序添加到虚方法末尾（这以Java单继承为前提）；若子类重写父类方法，则重写方法位置的入口地址修改成子类实现；
- 1）类加载解析阶段： 解析类的继承关系，生成类的虚方法表 （包含了这个类型全部方法的入口地址）。举个例子，有
Class B继承与Class A，并重写了A中的方法：
Object是全部类的父类，全部每一个类的虚方法表头部都会包含Object的虚方法表。另外，B重写了A#printMe()，因此对应位置的入口地址方法被修改成B重写方法的入口地址。
须要注意的是，被final、static或private修饰的方法不会出如今虚方法表中，由于这些方法没法被继承重写。
- 2）调用阶段（动态分派）： 解析阶段生成虚方法表后，每一个方法在虚方法表中的索引是固定的，这是不会随着实际类型变化影响的。调用方法时，首先根据变量的实际类型得到对应的虚方法表（包含了这个类型全部方法的入口地址），而后根据索引找到方法的入口地址。
invokeinterface指令
接口方法的选择行为与类方法的选择行为略有区别，主要缘由是Java接口是支持多继承的，就没办法像虚方法表那样直接继承父类的虚方法表。虚拟机提供了itable（interface method table）来支持多接口，itable由偏移量表offset table与方法表method table两部分组成。
当须要调用某个接口方法时，虚拟机会在offset table查找对应的method table，随后在该method table上查找方法。
3.4 性能对比
invokestatic & invokespecial能够直接调用方法入口地址，最快invokevirtual经过编号在vtable中查找方法，次之invokeinterface如今offset table中查找method table的偏移位置，随后在method table中查找接口方法的实现
4. 总结
- 方法调用的本质是从符号引用转换到直接引用（方法入口地址）的过程，一共须要通过（编译时）生成符号引用、（类加载时）解析、（调用时）动态分派三个步骤
invokestatic & invokespecial指令在（类加载时）解析时根据静态类型完成转换invokevirtual & invokeinterface在（调用时）根据实际类型，查找vtable & itable完成转换- 重载实际上是编译器的语法特性与多态无关，对编译时符号引用生成有影响，在运行时已经没有影响了；重写是多态的基础，虚拟机经过
vtable & itable来支持虚方法的方法选择。
参考资料
- 《深刻理解Java虚拟机（第3版本）》（第8章）—— 周志明 著
- 《深刻理解Android：Java虚拟机 ART》（第2章） —— 邓凡平 著
- 《深刻理解 JVM 字节码》（第二、3章）—— 张亚 著
创做不易，你的「三连」是丑丑最大的动力，咱们下次见！
- 1. 方法重写与重载的区别
- 2. Java中方法重写与方法重载的区别
- 3. Java中方法重载与方法重写的区别
- 4. 方法重写、方法重写和方法重载的区别
- 5. Java—重写与重载的区别
- 6. java方法重载与重写的特色与区别
- 7. java中方法重写（覆写）和方法重载的区别
- 8. 方法重载和重写的区别
- 9. java中重写与重载的区别
- 10. java中重载与重写的区别
- 更多相关文章...
- • C# 运算符重载 - C#教程
- • Web 品质 - 重要的 HTML 元素 - 网站品质教程
- • 适用于PHP初学者的学习线路和建议
- • Docker容器实战(八) - 漫谈 Kubernetes 的本质
-
每一个你不满意的现在，都有一个你没有努力的曾经。
- 1. 方法重写与重载的区别
- 2. Java中方法重写与方法重载的区别
- 3. Java中方法重载与方法重写的区别
- 4. 方法重写、方法重写和方法重载的区别
- 5. Java—重写与重载的区别
- 6. java方法重载与重写的特色与区别
- 7. java中方法重写（覆写）和方法重载的区别
- 8. 方法重载和重写的区别
- 9. java中重写与重载的区别
- 10. java中重载与重写的区别