静态分派与动态分派
作者：互联网
JAVA语言的三大特性为：继承，封装，多态。分派调用过程将会揭示多态特性的一些最基本的体现，如重写和重载。
一、静态分派
在介绍静态分派前，先来看一段一段代码
public class StaticDispatch {
static abstract class Human{
}
static class Man extends Human{
}
static class Woman extends Human{
}
public void sayHello(Human human){
System.out.println("hello,guy");
}
public void sayHello(Man man){
System.out.println("hello,man");
}
public void sayHello(Woman woman){
System.out.println("hello,woman");
}
public static void main(String[] args) {
Human man = new Man();
Human woman = new Woman();
StaticDispatch dispatch = new StaticDispatch();
dispatch.sayHello(man);
dispatch.sayHello(woman);
}
}输出结果：
hello,guy
hello,guy
虚拟机为什么会执行会执行参数为Human的重载版本呢？不妨先来分析一下这行代码
Human man = new Man();
这里面Human被称为man对象的静态类型（或外观类型），Man被称作变量的实际类型（或运行时类型）。静态类型和实际类型在运行时都可能会发生变化，但静态类型的变化仅在使用时发生，变量本身的静态类型不会被改变，并且最终的静态类型是在编译期可知的，而实际类型的变化结果只有在运行时才能确定。
对于重载方法，虚拟机通过参数的静态类型作为判定依据，因为静态类型在编译器可知，而JVM需要在编译期确定调用哪个重载方法，这时显然不会选择只有在运行期才会确定的实际类型。
因此，所有依赖静态类型来决定方法执行版本的分派动作，都称为静态分派。
二、动态分派
先来看下面一段代码
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 woman = new Woman();
man.sayHello();
woman.sayHello();
man = new Woman();
man.sayHello();
}
}输出结果：
man say hello
woman say hello
woman say hello
根据结果来看，对于sayHello()的调用是按照变量的实际类型来确定的，这是因为此时sayHello()方法的方法参数列表相同，不构成重载方法。而通过反编译后的字节码指令来看，调用方法之前，应先获取相应的对象，即下图16 17 和 20 21，先加载了man和woman的对象，再调用此方法。
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 com/cry/spring/Extend/DynamicDispatch$Man
3: dup
4: invokespecial #3 // Method com/cry/spring/Extend/DynamicDispatch$Man."<init>":()V
7: astore_1
8: new #4 // class com/cry/spring/Extend/DynamicDispatch$Woman
11: dup
12: invokespecial #5 // Method com/cry/spring/Extend/DynamicDispatch$Woman."<init>":()V
15: astore_2
16: aload_1
17: invokevirtual #6 // Method com/cry/spring/Extend/DynamicDispatch$Human.sayHello:()V
20: aload_2
21: invokevirtual #6 // Method com/cry/spring/Extend/DynamicDispatch$Human.sayHello:()V
24: new #4 // class com/cry/spring/Extend/DynamicDispatch$Woman
27: dup
28: invokespecial #5 // Method com/cry/spring/Extend/DynamicDispatch$Woman."<init>":()V
31: astore_1
32: aload_1
33: invokevirtual #6 // Method com/cry/spring/Extend/DynamicDispatch$Human.sayHello:()V
36: return
与之前StaticDispatch不同，之前StaticDispatch中，调用sayHello的对象均为dispatch，DynamicDispatch中调用方法的对象是两个不同的对象，因此才会出现不同的结果。
近一步来看，在动态分派中，起作用的主要是invokevirtual指令，该指令在运行时解析的过程如下：
1）找到操作数栈栈顶的第一个元素所指向的对象的实际类型，记为C。
2）如果在类C中找到与描述符和简单名称都匹配的方法，则进行方法权限检验，若有访问权限，则返回这个方法的直接引用，查找过程结束，否则，抛出IllegalAccessError异常。
3）否则，按照继承关系从下往上依次对C的各个父类进行第二步的搜索和验证过程。
4）如果还是没有找到合适的方法，则抛出AbstractMethodError异常。
但动态分派只对方法有效，对字段是无效的。
public class FieldHasNoPolymorphic {
static class Father{
int money =1;
}
static class Son extends Father{
int money =2;
}
public static void main(String[] args) {
Father guy = new Son();
System.out.println(guy.money);
}
}输出结果为1
也就是说即使子类也定义了money，但并不会受到动态分派的影响。因为字段不会用到invokeDynamic指令，也不会使虚的，换句话说，字段永远不参与多态。
标签：DynamicDispatch,静态,分派,sayHello,static,Human,动态,class,man 来源： https://blog.csdn.net/weixin_44105468/article/details/120519304