Java教程

静态分派与动态分派

本文主要是介绍静态分派与动态分派,对大家解决编程问题具有一定的参考价值,需要的程序猿们随着小编来一起学习吧!

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

这篇关于静态分派与动态分派的文章就介绍到这儿,希望我们推荐的文章对大家有所帮助,也希望大家多多支持为之网!