静态分派与动态分派

2021-09-27 23:59:40 阅读：155 来源： 互联网

标签：DynamicDispatch 静态分派 sayHello static Human 动态 class man

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

本站声明： 1. iCode9 技术分享网（下文简称本站）提供的所有内容，仅供技术学习、探讨和分享；
2. 关于本站的所有留言、评论、转载及引用，纯属内容发起人的个人观点，与本站观点和立场无关；
3. 关于本站的所有言论和文字，纯属内容发起人的个人观点，与本站观点和立场无关；
4. 本站文章均是网友提供，不完全保证技术分享内容的完整性、准确性、时效性、风险性和版权归属；如您发现该文章侵犯了您的权益，可联系我们第一时间进行删除；
5. 本站为非盈利性的个人网站，所有内容不会用来进行牟利，也不会利用任何形式的广告来间接获益，纯粹是为了广大技术爱好者提供技术内容和技术思想的分享性交流网站。

ICode9

静态分派与动态分派