Java方法调用解析静态分派动态分派执行过程

作者:攻城狮Chova 时间:2023-05-03 04:32:40 

方法调用

在程序运行时,进行方法调用是最普遍,最频繁的操作

方法调用不等于方法执行:

  • 方法调用阶段唯一的任务就是确定被调用的方法版本,即调用哪一个方法

  • 不涉及方法内部的具体运行过程

Class文件的编译过程不包括传统编译中的连接步骤

Class文件中的一切方法调用在Class文件里面存储的都是符号引用,而不是方法在在实际运行时内存布局中的入口地址,即之前的直接引用:

  • 这样使得Java具有更强大的动态扩展能力

  • 同时也使得Java方法调用过程变得相对复杂

  • 需要在类加载期间,甚至会到运行期间才能确定目标方法的直接引用

方法解析

所有方法调用中的目标方法在Class文件里都是一个常量池的引用

在类的加载解析阶段,会将其中的一部分符号引用转化为直接引用:

方法在程序真正执行之前就有一个可确定的调用版本,并且这个方法的调用版本在运行期是不可改变的

也就是说,调用目标在程序代码中完成,编译器进行编译时就必须确定下来,这也叫做方法解析

Java方法分类

在Java中符合 "编译期可知,运行期不可变" 的方法有两大类:

  • 静态方法: 与类型直接关联

  • 私有方法: 在外部不可被访问

这两种方法各自的特点决定这两种方法都不可能通过继承或者别的方式重写版本,因此适合在类加载阶段进行解析

非虚方法: 在类加载阶段会把符号引用解析为该方法的直接引用

  • 静态方法

  • 私有方法

  • 实例构造器

  • 父类方法

虚方法: 在类加载阶段不会将符号引用解析为该方法的直接引用

除去以上的非虚方法,其它的方法均为虚方法

静态分派

public class StaticDispatch {
static abstract class Human {
}
static class Man extends Human {
}
static class Woman extends Human {
}
public static void sayHello(Human guy) {
System.out.println("Hello, Guy!");
}
public static void sayHello(Man guy) {
System.out.println("Hello, Gentleman!");
}
public static void sayHello(woman guy) {
System.out.println("Hello, Lady!");
}
public static void main(String[] args) {
Human man = new Man();
Human women = new Woman();
sayHello(man);
sayHello(woman);
}
}

Human man = new Human();

Human为变量的静态类型

Man为变量的实际类型

静态类型和实际类型在程序中都会放生变化:

静态类型:

  • 静态类型的变化仅仅在使用时发生

  • 变量本身的静态类型不会被改变

  • 最终的静态类型在编译器中可知

实际类型:

  • 实际类型变化的结果在运行期才确定下来

  • 编译器在编译期间并不知道一个对象的实际类型是什么

Human human = new Man();
sayHello(man);
sayHello((Man)man);// 类型转换,静态类型变化,转型后的静态类型一定是Man
man = new woman();// 实际类型变化,实际类型是不确定的
sayHello(man);
sayHello((Woman)man);// 类型转换,静态类型变化

编译器在重载时是通过参数的静态类型而不是实际类型作为判断依据,静态类型在编译期间可以知道:

编译阶段,Javac编译器会根据参数的静态类型决定使用哪个重载版本

静态分派:

  • 所有依赖静态类型来定位方法的执行版本的分派动作

  • 典型应用 :方法重载

静态分派发生在编译阶段,因此确定静态分派的的动作不是由虚拟机执行的,而是由编译器完成的

由于字面量没有显示静态类型,只能通过语言上的规则去理解和推断

public class LiteralTest {
public static void sayHello(char arg) {
System.out.println("Hello, char!");
}
public static void sayHello(int arg) {
System.out.println("Hello, int!");
}
public static void sayHello(long arg) {
System.out.println("Hello, long!");
}
public static void sayHello(Character arg) {
System.out.println("Hello, Character!");
}
public static void main(String[] arg) {
sayHello('a');
}
}

编译器将重载方法从上向下依次注释,得到不同的输出

如果编译器无法确定要自定转型为哪种类型,会提示类型模糊,拒绝编译

public class LiteralTest {
public static void sayHello(String arg) {// 新增重载方法
System.out.println("Hello, String!");
}
public static void sayHello(char arg) {
System.out.println("Hello, char!");
}
public static void sayHello(int arg) {
System.out.println("Hello, int!");
}
public static void sayHello(long arg) {
System.out.println("Hello, long!");
}
public static void sayHello(Character arg) {
System.out.println("Hello, Character!");
}
public static void main(String[] args) {
Random r = new Random();
String s = "abc";
int i = 0;
sayHello(r.nextInt() % 2 != 0 ? s : 1 );// 编译错误
sayHello(r.nextInt() % 2 != 0 ? 'a' : false);//编译错误
}
}

动态分派

public class DynamicDispatch {
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 women = new Woman();
man.sayHello();
woman.sayHello();
man = new Woman();
man.sayHello();
}
}

这里不是根据静态类型决定的

  • 静态类型的Human两个变量man和woman在调用sayHello() 方法时执行了不同的行为

  • 变量man在两次调用中执行了不同的方法

导致这个现象的额原因 :这两个变量的实际类型不同

Java虚拟机是如何根据实际类型分派方法的执行版本的: 从invokevirtual指令的多态查找过程开始 ,invokevirtual指令运行时解析过程大致分为以下几个步骤:

  • 找到操作数栈顶的第一个元素所指向的对象的实际类型,记作C

  • 如果在类型C中找到与常量中的描述符和简单名称相符合的方法,然后进行访问权限验证,如果验证通过则返回这个方法的直接引用,查找过程结束;如果验证不通过,则抛出java.lang.illegalAccessError异常

  • 如果未找到,就按照继承关系从下往上依次对类型C的各个父类进行第二步的搜索和验证过程

  • 如果始终没有找到合适的方法,则抛出java.lang.AbstractMethodError异常

Java语言方法重写的本质:

invokevirtual指令执行的第一步就是在运行时期确定接收者的实际类型,所以两次调用中的invokevirtual指令把常量池中的类方法符号引用解析到了不同的直接引用上

这种在运行时期根据实际类型确定方法执行版本的分派过程就叫做动态分派

虚拟机动态分派的实现

虚拟机概念解析的模式就是静态分派和动态分派,可以理解虚拟机在分派中 "会做什么" 这个问题

虚拟机 "具体是如何做到的" 在各种虚拟机实现上会有差别:

  • 由于动态分派是非常频繁的动作,而且动态分派的方法版本选择过程需要运行时在类的方法元数据中搜索合适的目标方法

  • 因此在虚拟机的实际实现中,为了基于性能的考虑,大部分实现都不会真正的进行如此频繁的搜索

  • 最常用的"稳定优化"的方式是为类在方法区中建立一个虚方法表(Virtual Method Table,即vtable), 使用虚方法表索引代替元数据查找以提高性能

虚方法表中存放着各个方法的实际入口地址:

  • 如果某个方法在子类中没有被重写,那子类的虚方法表里面的地址入口和父类相同方法的地址入口是一致的,都指向父类的实际入口

  • 如果子类中重写了这个方法,子类方法表中的地址将会替换为指向子类实际方法的入口地址

具有相同签名的方法,在父类,子类的虚方法表中具有一样的索引序号:

这样当类型变换时,仅仅需要变更查找的方法表,就可以从不同的虚方法表中按索引转换出所需要的入口地址

方法表一般在类加载阶段的连接阶段进行初始化:

准备了类的变量初始值后,虚拟机会把该类的方法表也初始化完毕

来源:https://cloud.tencent.com/developer/article/1938329?from=article.detail.1905407

标签:Java,静态分派,动态分派,执行过程,方法调用
0
投稿

猜你喜欢

  • C#实现控制台飞行棋小游戏

    2023-01-01 15:43:12
  • Java线程池ThreadPoolExecutor原理及使用实例

    2022-04-30 05:53:00
  • 详解java IO流之缓冲流的使用

    2023-08-08 18:33:16
  • C#集合之有序列表的用法

    2023-10-02 15:47:02
  • Mybatis-Plus 新增获取自增列id方式

    2021-10-22 17:06:38
  • springboot aspect通过@annotation进行拦截的实例代码详解

    2023-10-15 20:12:54
  • 详解Java中LinkedHashMap

    2022-05-23 16:24:45
  • Mybatis Interceptor 拦截器的实现

    2022-11-02 05:05:44
  • android判断手机是否安装地图应用实现跳转到该地图应用

    2022-11-30 11:01:45
  • C#构建树形结构数据(全部构建,查找构建)

    2022-07-22 12:22:52
  • Spring Security+JWT实现认证与授权的实现

    2022-04-02 00:41:11
  • Android简单使用PopupWindow的方法

    2023-09-13 19:51:22
  • Android中使用ZXing生成二维码(支持添加Logo图案)

    2023-12-24 21:34:58
  • Java Web实现添加定时任务的方法示例

    2023-11-25 02:12:15
  • 使用递归实现数组求和示例分享

    2023-04-24 02:17:40
  • C# Winform多屏幕多显示器编程技巧实例

    2021-09-19 16:49:09
  • Java Idea高效率配置技巧实例解析

    2023-06-05 13:24:42
  • c#检测文本文件编码的方法

    2021-09-16 03:33:43
  • @Autowired注解注入的xxxMapper报错问题及解决

    2022-10-01 10:31:02
  • C#正则实现Ubb解析类的代码

    2021-10-23 22:19:38
  • asp之家 软件编程 m.aspxhome.com