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指令，也不会使虚的，换句话说，字段永远不参与多态。