今天遇到一个问题：子类重写父类中的方法之后，后期虚拟机是如何确定要执行的方法？
要解决上面的那个问题，我们先来看看Java中的方法调用。方法调用并不等同于方法执行，方法调用阶段唯一的任务就是确定被调用方法的版本（即要执行哪一个方法），他还不会设计方法内部的具体运行过程。
所有方法调用中的目标方法在Class文件里面都是一个常量池中的符号引用，在类加载的解析阶段，会将其中一部分的符号引用转换为直接引用。这种解析能够成立的前提是：方法在程序可以运行之前就有一个可确定的调用版本，并且这个方法的调用版本在运行期是不可改变的。换句话说，调用目标在程序代码写好，编译器进行
编译时就必须确定下来，这类方法的调用称为解析。
Java语言中符合“编译期可知，运行期不可变”的方法主要包括静态方法和私有方法两大类。前者直接和类型关联，后者在外部不可访问。他们的特点都决定了他们不可能通过继承或者别的方式重写其他版本（注：前面一篇文章中已经指出父类的private成员是不会被子类继承的），因此他们是和在类加载阶段解析（将符号引用解析为直接引用）。与之对应的是，在Java虚拟机中提供了5条调用字节码指令，分别如下：
a) invokestatic：调用静态方法；
b) invokespecial：调用实例构造器<init>方法、私有方法和父类方法
c) invokevirtual：调用所有的虚方法
d) invokeinterface：调用接口方法，会在运行时再确定一个实现此接口的对象
e) invokedynamic：先在运行时动态解析出调用点限定符所引用的方法，然后再执行该方法。
只要能被invokestatic和invokespecial指令调用的方法，都可以在解析阶段确定唯一的调用版本，符合这个条件的有：静态方法，私有方法，实例构造器(也属于static方法)、父类方法。他们也被称为非虚方法。
看一个例子：
public class StaticResolution {
public static void sayHello() {
System.out.println("Hello");
}
public static void main(String[] args) {
StaticResolution.sayHello();
}
}
使用javap命令反汇编之后的字节码如下：命令：javap -verbose StaticResolution;
Classfile /C:/Users/Administrator/Desktop/TempFiles/StaticResolution.class
Last modified 2016-7-21; size 498 bytes
MD5 checksum 6843913113abaaced35c02b2c718f3f6
Compiled from "StaticResolution.java"
public class StaticResolution
SourceFile: "StaticResolution.java"
minor version: 0
major version: 52
flags: ACC_PUBLIC, ACC_SUPER
Constant pool:
#1 = Methodref #7.#17 // java/lang/Object."<init>":()V
#2 = Fieldref #18.#19 // java/lang/System.out:Ljava/io/PrintStream;
#3 = String #20 // Hello
#4 = Methodref #21.#22 // java/io/PrintStream.println:(Ljava/lang/String;)V
#5 = Methodref #6.#23 // StaticResolution.sayHello:()V
#6 = Class #24 // StaticResolution
#7 = Class #25 // java/lang/Object
#8 = Utf8 <init>
#9 = Utf8 ()V
#10 = Utf8 Code
#11 = Utf8 LineNumberTable
#12 = Utf8 sayHello
#13 = Utf8 main
#14 = Utf8 ([Ljava/lang/String;)V
#15 = Utf8 SourceFile
#16 = Utf8 StaticResolution.java
#17 = NameAndType #8:#9 // "<init>":()V
#18 = Class #26 // java/lang/System
#19 = NameAndType #27:#28 // out:Ljava/io/PrintStream;
#20 = Utf8 Hello
#21 = Class #29 // java/io/PrintStream
#22 = NameAndType #30:#31 // println:(Ljava/lang/String;)V
#23 = NameAndType #12:#9 // sayHello:()V
#24 = Utf8 StaticResolution
#25 = Utf8 java/lang/Object
#26 = Utf8 java/lang/System
#27 = Utf8 out
#28 = Utf8 Ljava/io/PrintStream;
#29 = Utf8 java/io/PrintStream
#30 = Utf8 println
#31 = Utf8 (Ljava/lang/String;)V
{
public StaticResolution();
descriptor: ()V
flags: ACC_PUBLIC
Code:
stack=1, locals=1, args_size=1
0: aload_0
1: invokespecial #1 // Method java/lang/Object."<init>":()V
4: return
LineNumberTable:
line 1: 0
public static void sayHello();
descriptor: ()V
flags: ACC_PUBLIC, ACC_STATIC
Code:
stack=2, locals=0, args_size=0
0: getstatic #2 // Field java/lang/System.out:Ljava/io/PrintStream;
3: ldc #3 // String Hello
5: invokevirtual #4 // Method java/io/PrintStream.println:(Ljava/lang/String;)V
8: return
LineNumberTable:
line 3: 0
line 4: 8
public static void main(java.lang.String[]);
descriptor: ([Ljava/lang/String;)V
flags: ACC_PUBLIC, ACC_STATIC
Code:
stack=0, locals=1, args_size=1
0: invokestatic #5 // Method sayHello:()V
3: return
LineNumberTable:
line 6: 0
line 7: 3
}
在main()方法中使用invokestatic指令调用了static方法。
注：Java中的非虚方法除了使用invokestatic、invokespecial调用的方法之外还有另外一种，就是被final修饰的方法，虽然它是使用invokevirtual指令调用的，但是由于无法被覆盖，没有其他版本，所以也无需对方法进行多态选择，所以也是非虚方法。。
总的来说：解析调用一定是一个静态的过程。在编译期间就完全确定，在类装载的解析阶段就把涉及的所有符号引用全部转换称为可确定的直接引用，不会到运行期再去完成。
与之不同的是，分派既可能是静态的也可能是动态的。
我们先来看一下静态分派：下面是一段程序代码，并猜一下输出是什么：
package com.demo.org;
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 man) {
System.out.println("Hello, gentleman");
}
public void sayHello(Woman woman) {
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);
}
}
输出结果：
Hello, guy
Hello, guy
有些人感觉很奇怪，不应该是根据引用实际指向的对象类型去调用不同的方法吗？在解决这两个问题之前，我们要先了解两个重要概念：
Human man = new Man();
上面的Human称为变量的静态类型，或者叫做外观类型；后面的Man则称为变量的实际类型。静态类型和实际类型在程序中都可以发生一些变化，区别是：静态类型的变化仅仅在使用时发生，变量本身的静态类型不会改变，并且最终的静态类型是在编译期可知的；而实际类型变化的结果是在运行期才可确定，编译的时候是不知道实际类型是什么的。
// 实际类型变化
Human man = new Man();
man = new Woman();
// 静态类型变化
sr.sayHello((Man) man);
sr.sayHello((Woman) man);
了解了这两个概念，再回头看前面的两次方法调用，在已经确定接收者是sr的前提下，使用哪个重载版本，就完全取决于传入参数的数量和数据类型。
代码中可以定义了两个静态类型相同但实际类型不同的变量，但虚拟机（准确的说是编译器）在重载时是通过静态类型而不是实际类型作为依据的。并且静态类型是在编译期已经确定的，因此调用哪个重载方法已经是在编译期间确定了的（根据静态类型选择）。
我们再从字节码的角度看下：
Constant pool:
#1 = Methodref #14.#32 // java/lang/Object."<init>":()V
#2 = Fieldref #33.#34 // java/lang/System.out:Ljava/io/PrintStream;
#3 = String #35 // Hello, guy
#4 = Methodref #36.#37 // java/io/PrintStream.println:(Ljava/lang/String;)V
#5 = String #38 // Hello, gentleman
#6 = String #39 // Hello, lady
#7 = Class #40 // StaticDispatch$Man
#8 = Methodref #7.#32 // StaticDispatch$Man."<init>":()V
#9 = Class #41 // StaticDispatch$Woman
#10 = Methodref #9.#32 // StaticDispatch$Woman."<init>":()V
#11 = Class #42 // StaticDispatch
#12 = Methodref #11.#32 // StaticDispatch."<init>":()V
#13 = Methodref #11.#43 // StaticDispatch.sayHello:(LStaticDispatch$Human;)V
#14 = Class #44 // java/lang/Object
#15 = Utf8 Woman
#16 = Utf8 InnerClasses
#17 = Utf8 Man
#18 = Class #45 // StaticDispatch$Human
#19 = Utf8 Human
#20 = Utf8 <init>
#21 = Utf8 ()V
#22 = Utf8 Code
#23 = Utf8 LineNumberTable
#24 = Utf8 sayHello
#25 = Utf8 (LStaticDispatch$Human;)V
#26 = Utf8 (LStaticDispatch$Man;)V
#27 = Utf8 (LStaticDispatch$Woman;)V
#28 = Utf8 main
#29 = Utf8 ([Ljava/lang/String;)V
#30 = Utf8 SourceFile
#31 = Utf8 StaticDispatch.java
#32 = NameAndType #20:#21 // "<init>":()V
#33 = Class #46 // java/lang/System
#34 = NameAndType #47:#48 // out:Ljava/io/PrintStream;
#35 = Utf8 Hello, guy
#36 = Class #49 // java/io/PrintStream
#37 = NameAndType #50:#51 // println:(Ljava/lang/String;)V
#38 = Utf8 Hello, gentleman
#39 = Utf8 Hello, lady
#40 = Utf8 StaticDispatch$Man
#41 = Utf8 StaticDispatch$Woman
#42 = Utf8 StaticDispatch
#43 = NameAndType #24:#25 // sayHello:(LStaticDispatch$Human;)V
#44 = Utf8 java/lang/Object
#45 = Utf8 StaticDispatch$Human
#46 = Utf8 java/lang/System
#47 = Utf8 out
#48 = Utf8 Ljava/io/PrintStream;
#49 = Utf8 java/io/PrintStream
#50 = Utf8 println
#51 = Utf8 (Ljava/lang/String;)V
{
public StaticDispatch();
descriptor: ()V
flags: ACC_PUBLIC
Code:
stack=1, locals=1, args_size=1
0: aload_0
1: invokespecial #1 // Method java/lang/Object."<init>":()V
4: return
LineNumberTable:
line 1: 0
line 4: 4
public void sayHello(StaticDispatch$Human);
descriptor: (LStaticDispatch$Human;)V
flags: ACC_PUBLIC
Code:
stack=2, locals=2, args_size=2
0: getstatic #2 // Field java/lang/System.out:Ljava/io/PrintStream;
3: ldc #3 // String Hello, guy
5: invokevirtual #4 // Method java/io/PrintStream.println:(Ljava/lang/String;)V
8: return
LineNumberTable:
line 7: 0
line 8: 8
public void sayHello(StaticDispatch$Man);
descriptor: (LStaticDispatch$Man;)V
flags: ACC_PUBLIC
Code:
stack=2, locals=2, args_size=2
0: getstatic #2 // Field java/lang/System.out:Ljava/io/PrintStream;
3: ldc #5 // String Hello, gentleman
5: invokevirtual #4 // Method java/io/PrintStream.println:(Ljava/lang/String;)V
8: return
LineNumberTable:
line 11: 0
line 12: 8
public void sayHello(StaticDispatch$Woman);
descriptor: (LStaticDispatch$Woman;)V
flags: ACC_PUBLIC
Code:
stack=2, locals=2, args_size=2
0: getstatic #2 // Field java/lang/System.out:Ljava/io/PrintStream;
3: ldc #6 // String Hello, lady
5: invokevirtual #4 // Method java/io/PrintStream.println:(Ljava/lang/String;)V
8: return
LineNumberTable:
line 15: 0
line 16: 8
public static void main(java.lang.String[]);
descriptor: ([Ljava/lang/String;)V
flags: ACC_PUBLIC, ACC_STATIC
Code:
stack=2, locals=4, args_size=1
0: new #7 // class StaticDispatch$Man
3: dup
4: invokespecial #8 // Method StaticDispatch$Man."<init>":()V
7: astore_1
8: new #9 // class StaticDispatch$Woman
11: dup
12: invokespecial #10 // Method StaticDispatch$Woman."<init>":()V
15: astore_2
16: new #11 // class StaticDispatch
19: dup
20: invokespecial #12 // Method "<init>":()V
23: astore_3
24: aload_3
25: aload_1
26: invokevirtual #13 // Method sayHello:(LStaticDispatch$Human;)V
29: aload_3
30: aload_2
31: invokevirtual #13 // Method sayHello:(LStaticDispatch$Human;)V
34: return
LineNumberTable:
line 18: 0
line 19: 8
line 20: 16
line 21: 24
line 22: 29
line 23: 34
}
0-23行属于准备阶段，主要是执行构造器方法，创建变量（从虚拟机的角度是作用是建立man和woman的内存空间、调用Man和Woman以及StaticDispatch类型的构造器，然后将这三个实例的引用存放在第1、2、3个局部变量表slot中），第24行将栈顶元素出栈，然后再将第一个对象出栈，然后使用invokevirtual指令调用方法，该方法指向常量池中第13行的记录，也即Human中的方法。
下面再说一下动态分派，他和多态的另外一个重要体现——重写有着密切的关联。接着看下面的一个演示示例：
public class DynamicDispatch {
static abstract class Human {
public abstract void sayHello();
}
static class Man extends Human {
@Override
public void sayHello() {
System.out.println("Hello man");
}
}
static class Woman extends Human {
@Override
public void sayHello() {
System.out.println("Hello woman");
}
}
public static void main(String[] args) {
Human man = new Man();
Human woman = new Woman();
man.sayHello();
woman.sayHello();
man = new Woman();
man.sayHello();
}
}
// 输出结果：
Hello man
Hello woman
Hello woman
看到这个结果，有些人可能感觉理所当然，这符合多态的特点。但是有些人可能还是会觉得有些不对。从结果中也可以看出，这里不可能再是根据静态类型来决定，因为静态类型的man和woman在调用sayHello()方法的时候体现了不同的行为，并且变量man在两次调用中执行了不同的方法。导致这个的原因很明显，他们的实际类型不同。我们再次使用javap命令将代码进行反汇编：
Constant pool:
#1 = Methodref #8.#22 // java/lang/Object."<init>":()V
#2 = Class #23 // DynamicDispatch$Man
#3 = Methodref #2.#22 // DynamicDispatch$Man."<init>":()V
#4 = Class #24 // DynamicDispatch$Woman
#5 = Methodref #4.#22 // DynamicDispatch$Woman."<init>":()V
#6 = Methodref #12.#25 // DynamicDispatch$Human.sayHello:()V
#7 = Class #26 // DynamicDispatch
#8 = Class #27 // java/lang/Object
#9 = Utf8 Woman
#10 = Utf8 InnerClasses
#11 = Utf8 Man
#12 = Class #28 // DynamicDispatch$Human
#13 = Utf8 Human
#14 = Utf8 <init>
#15 = Utf8 ()V
#16 = Utf8 Code
#17 = Utf8 LineNumberTable
#18 = Utf8 main
#19 = Utf8 ([Ljava/lang/String;)V
#20 = Utf8 SourceFile
#21 = Utf8 DynamicDispatch.java
#22 = NameAndType #14:#15 // "<init>":()V
#23 = Utf8 DynamicDispatch$Man
#24 = Utf8 DynamicDispatch$Woman
#25 = NameAndType #29:#15 // sayHello:()V
#26 = Utf8 DynamicDispatch
#27 = Utf8 java/lang/Object
#28 = Utf8 DynamicDispatch$Human
#29 = Utf8 sayHello
{
public static void main(java.lang.String[]);
descriptor: ([Ljava/lang/String;)V
flags: ACC_PUBLIC, ACC_STATIC
Code:
stack=2, locals=3, args_size=1
0: new #2 // class DynamicDispatch$Man
3: dup
4: invokespecial #3 // Method DynamicDispatch$Man."<init>":()V
7: astore_1
8: new #4 // class DynamicDispatch$Woman
11: dup
12: invokespecial #5 // Method DynamicDispatch$Woman."<init>":()V
15: astore_2
16: aload_1
17: invokevirtual #6 // Method DynamicDispatch$Human.sayHello:()V
20: aload_2
21: invokevirtual #6 // Method DynamicDispatch$Human.sayHello:()V
24: new #4 // class DynamicDispatch$Woman
27: dup
28: invokespecial #5 // Method DynamicDispatch$Woman."<init>":()V
31: astore_1
32: aload_1
33: invokevirtual #6 // Method DynamicDispatch$Human.sayHello:()V
36: return
LineNumberTable:
line 18: 0
line 19: 8
line 20: 16
line 21: 20
line 22: 24
line 23: 32
line 24: 36
}
0-15行的字节码是准备动作，作用是建立man和woman的内存空间、调用Man和Woman类型的构造器，将这两个实例的引用存放在第1、2个局部变量表slot中。（注：他其实对应了两个创建对象的语句）；
接下来的16-21行是最关键的地方，16、20两行将刚创建的两个对象的引用压到栈顶，这两个对象是即将执行的sayHello方法的所有者，称为接收者。17和21行是方法调用指令，无论是指令（都是invokevirtual）还是参数（都是常量池中第6项中的常量，注释显示了这个常量是Human.sayHello()的符号引用）完全一样的，但是这两句指令最终执行的目标方法不同。原因要从invokevirtual指令的多态查找过程开始说起。
invokevirtual指令的运行时解析过程大概是分为以下几个步骤：
a) 找到操作数栈顶的第一个元素所指向的对象的实际类型，记作C；
b) 如果在类型C中找到与常量中的描述符和简单名称都相同的方法，则进行访问权限的校验，如果通过则返回这个方法的直接引用，查找过程结束；如果不通过，则返回java.lang.IllegalAccessError异常；
c) 否则按照继承关系从下往上依次对C的各个父类进行第2步的搜索和验证过程。
d) 如果始终没找到合适的方法，则抛出java.lang.AbstractMethodError.
由于invokevirtual指令的第一步就是在运行时期确定接受者的实际类型，所以两次调用中的invokevirtual指令把常量池中的类方法符号引用解析到了不同的直接引用上，这个过程就是Java语言中方法重写的本质。
注：以上绝大部分内容都是参照或直接引用深入理解Java虚拟机一书中的内容，在此表示感谢。
相关推荐
这个压缩包中的内容可能包含了一系列使用JavaParser进行代码分析的示例或工具，特别是关于方法调用链的分析。这种方法调用链分析在软件工程中具有重要的应用价值，比如代码审查、性能优化、依赖关系理解以及重构等。...
Java反射是Java编程语言中的一个强大特性，它允许在运行时检查类、接口、字段和方法的信息，并且能够在运行时动态地创建对象和调用方法。这个特性使得Java具有了高度的灵活性，常用于框架开发、插件系统、元编程等...
### Java远程方法调用（RMI）：深入解析与实践 #### 一、RMI概念与原理 Java远程方法调用（Remote Method Invocation，简称RMI）是Java平台提供的一种分布式计算模型，允许一个Java虚拟机（JVM）上的对象通过网络...
Java调用Groovy类则稍微复杂一些，通常有两种主要方法： 1. **方法1：直接调用** - 如果你的开发环境（如IntelliJ IDEA或Eclipse）已经安装了Groovy解释器插件，那么可以直接在Java代码中像调用Java类一样调用...
在此过程中，可以使用`Transformer`的`setURIResolver()`方法来定义自定义URI解析器，该解析器可以调用Java方法。 示例： ```java TransformerFactory factory = TransformerFactory.newInstance(); ...
55.java方法调用.zip55.java方法调用.zip55.java方法调用.zip55.java方法调用.zip55.java方法调用.zip55.java方法调用.zip55.java方法调用.zip55.java方法调用.zip55.java方法调用.zip55.java方法调用.zip55.java...
Java动态调用方法是Java反射机制的一个重要应用，它允许我们在程序运行时，根据需要动态地获取类的信息并调用其方法。这种能力为代码的灵活性和可扩展性提供了强大的支持，尤其在处理不确定的对象类型或者需要在运行...
Android Studio项目，此Demo实现Java调用C++函数，然后C++函数回调Java方法、纯C++直接调用Java方法，此为github地址链接
综上所述，Java中的方法调用非常灵活且强大。理解如何在一个类内部调用方法是编写高效、易于维护的Java程序的关键。无论是静态方法还是非静态方法，掌握正确的调用方式都能帮助开发者有效地组织和优化代码结构。随着...
总结来说，Java调用Python代码是通过各种工具和库实现的，如Jython、Py4J等。这些方法各有优缺点，开发者应根据项目需求、性能和兼容性等因素来选择最合适的方式。在实际项目中，通过实践和调试这些工具，可以更好地...
本篇文章将详细探讨如何在C#中调用Java方法，以及与之相关的技术，包括IKVM.NET。我们将通过提供的资源，即“UseJAVA.rar”和“JAVADemo.rar”，来了解具体的实现过程。 首先，让我们理解C#调用Java方法的基本原理...
标题"java调用c#样例"指的是使用Java语言通过Jacob库调用C#编写的动态链接库（DLL）。C# DLL通常包含.NET Framework中的方法和功能，而Java应用程序可以借助Jacob库来访问这些功能，从而实现跨语言的互操作性。 ...
Java是一种跨平台的编程语言，但在与底层操作系统交互时，比如调用Windows系统的动态链接库（DLL）中的方法，就需要一些特殊的工具和技术。本实例主要介绍如何使用Java和jawin库来实现DLL方法的调用。 jawin是一个...
2. **调用Java方法**：在XSLT模板中通过指定的前缀和完整的类名加方法名来调用Java方法，并传入相应的参数。 ```xml <xsl:value-of select='java:XsltFunctions.replace(.)'/> ``` #### 四、实例演示 为了更好...
Java远程方法调用（Remote Method Invocation，简称RMI）组件是一种关键的技术，它允许Java应用程序在不同的网络节点之间透明地调用对象的方法，仿佛这些对象都在本地进程中一样。这种技术在构建分布式系统、大型...
57.java带参数方法调用.zip57.java带参数方法调用.zip57.java带参数方法调用.zip57.java带参数方法调用.zip57.java带参数方法调用.zip57.java带参数方法调用.zip57.java带参数方法调用.zip57.java带参数方法调用.zip...
"java调用js方法.doc"很可能是详细描述如何从Java调用JS函数的步骤和示例。 在实际应用中，Java代码可能会通过Ajax发送一个请求到服务器，服务器解析请求后调用对应的JS函数，例如在"des.js"中执行解密操作，然后将...
6. **测试Java调用C函数** 在Java程序中，现在可以通过`callCFunction`调用C代码： ```java public class Main { public static void main(String[] args) { NativeDemo demo = new NativeDemo(); demo....
在这个主题中，我们将深入探讨如何使用Java反射来调用不同类型的参数方法，包括无参方法、Object类型参数的方法、基本类型参数的方法以及数组参数的方法，以及如何调用私有方法。 首先，要调用无参方法，我们可以...
Java异步调用转同步方法实例详解是指在Java中将异步调用转换为同步调用的技术，主要用于解决异步调用过程中的阻塞问题。异步调用是一种非阻塞的调用方式，调用方在调用过程中，不直接等待返回结果，而是执行其他任务...