JVM 之（16）方法调用

前言

Java具有三种特性：封装、继承、多态。
Java文件在编译过程当中不会进行传统编译的链接步骤，方法调用的目标方法以符号引用的方式存储在Class文件中，这种多态特性给Java带来了更灵活的扩展能力，但也使得方法调用变得相对复杂，须要在类加载期间，甚至到运行期间才能肯定目标方法的直接引用。

方法调用

全部方法调用的目标方法在Class文件里面都是常量池中的符号引用。在类加载的解析阶段，若是一个方法在运行以前有肯定的调用版本，且在运行期间不变，虚拟机会将其符号引用解析为直接调用。

这种 编译期可知，运行期不可变 的方法，主要包括静态方法和私有方法两大类，前者与具体类直接关联，后者在外部不可访问，二者都不能经过继承或别的方式进行重写。

JVM提供了以下方法调用字节码指令：

1. invokestatic：调用静态方法；
2. invokespecial：调用实例构造方法<init>，私有方法和父类方法；
3. invokevirtual：调用虚方法；
4. invokeinterface：调用接口方法，在运行时再肯定一个实现此接口的对象；
5. invokedynamic：在运行时动态解析出调用点限定符所引用的方法以后，调用该方法；

经过invokestatic和invokespecial指令调用的方法，能够在解析阶段肯定惟一的调用版本，符合这种条件的有静态方法、私有方法、实例构造器和父类方法4种，它们在类加载时会把符号引用解析为该方法的直接引用。

public class InvokestaticTest {
    
    InvokestaticTest(){
        
    }
    
    public static void sayHello() {
        System.out.println("hello");
    }
    public static void main(String args[]) {
        sayHello();
    }
}

javap  -verbose  InvokestaticTest.class

能够发现实例构造器是经过invokespecial指令调用的, sayHello方法是经过invokestatic指令调用的。
经过invokestatic和invokespecial指令调用的方法，能够称为非虚方法，其他状况称为虚方法，不过有一个特例，即被final关键字修饰的方法，虽然使用invokevirtual指令调用，因为它没法被覆盖重写，因此也是一种非虚方法。

非虚方法的调用是一个静态的过程，因为目标方法只有一个肯定的版本，因此在类加载的解析阶段就能够把符合引用解析为直接引用，而虚方法的调用是一个分派的过程，有静态也有动态，可分为静态单分派、静态多分派、动态单分派和动态多分派。

静态分派

静态分派发生在代码的编译阶段。针对于方法的重载

public class StaticDispatch {

    static class Parent{}
    static class Child1 extends Parent{}
    static class Child2 extends Parent{}

    public void sayHello(Parent parent){
        System.out.println("parent sayHello");
    }
    public void sayHello(Child1 child1){
        System.out.println("child1 sayHello");
    }
    public void sayHello(Child2 child2){
        System.out.println("child2 sayHello");
    }

    public static void main(String[] args) {
        Parent parent = new Parent();
        Parent parent1 = new Child1();
        Parent parent2 = new Child2();

        StaticDispatch staticDispatch = new StaticDispatch();
        staticDispatch.sayHello(parent);
        staticDispatch.sayHello(parent1);
        staticDispatch.sayHello(parent2);
        staticDispatch.sayHello((Child2)parent2);
    }
}

parent sayHello
parent sayHello
parent sayHello
child2 sayHello

javap  -verbose StaticDispatch.class

经过字节码指令，能够发现四次hello方法都是经过invokevirtual指令进行调用，并且前三次调用的是参数为Parent类型的sayHello方法，最后一次进行强转后，调用Child2类型的sayHello方法。

再举个例子，代码以下：

public class StaticDispatchTest {

    public void sayHello(short word){
        System.out.println("short" + word);
    }
    public void sayHello(int word){
        System.out.println("int" + word);
    }
    public void sayHello(long word){
        System.out.println("long" + word);
    }
    public void sayHello(String word){
        System.out.println("String" + word);
    }
    public void sayHello(char word){
        System.out.println("char" + word);
    }
    public void sayHello(Character word){
        System.out.println("Character" + word);
    }
    public void sayHello(Object word){
        System.out.println("Object" + word);
    }
    public void sayHello(char ... word){
        System.out.println("char ..." + word);
    }

    public static void main(String[] args) {
        StaticDispatchTest staticDispatch = new StaticDispatchTest();
        staticDispatch.sayHello('a');
    }
}

chara

优先匹配到char方法，其次是int，long，Character, Objedt, char...

        在编译阶段，Java编译器会根据参数的静态类型决定调用哪一个重载版本，但在有些状况下，重载的版本不是惟一的，这样只能选择一个“更加合适的版本”进行调用，因此不建议在实际项目中使用这种模糊的方法重载。

动态分派

         在运行期间根据参数的实际类型肯定方法执行版本的过程称为动态分派，动态分派和多态性中的重写（override）有着紧密的联系。
         因为动态分派是很是频繁的动做，所以在虚拟机的实际实现中，会基于性能的考虑，并不会如此频繁的搜索对应方法，通常会在方法区中创建一个虚方法表，使用虚方法表代替方法查询以提升性能。
        虚方法表在类加载的链接阶段进行初始化，存放着各个方法的实际入口地址，若是某个方法在子类中没有被重写，那么子类的虚方法表中该方法的入口地址和父类保持一致。
        一个类的方法表包含类的全部方法入口地址，从父类继承的方法放在前面，接下来是接口方法和自定义的方法。若是某个方法在子类中没有被重写，那子类的虚方法表里面的地址入口和父类相同的方法的入口地址一致。若是子类重写了这个方法，子类方法表中的地址将会替换为指向子类实现版本的入口地址。

public class DynamicDispatch {

    static class Parent{
        public void sayHello(){
            System.out.println("Parent");
        }
    }
    static class Child1 extends Parent {
        public void sayHello(){
            System.out.println("Child1");
        }
    }
    static class Child2 extends Parent {
        public void sayHello(){
            System.out.println("Child2");
        }
    }
    public static void main(String[] args) {
        Parent parent = new Parent();
        Parent parent1 = new Child1();
        Parent parent2 = new Child2();

        parent.sayHello();
        parent1.sayHello();
        parent2.sayHello();
    }
}

Parent
Child1
Child2

javap  -verbose DynamicDispatch.class

能够发现，2五、29和33的指令彻底同样，但最终执行的目标方法却不相同，这得从invokevirtual指令的多态查找提及了，invokevirtual指令在运行时分为如下几个步骤：

1. 找到操做数栈的栈顶元素所指向的对象的实际类型，记为C；
2. 若是类型C中存在描述符和简单名称都相符的方法，则进行访问权限验证，若是验证经过，则直接返回这个方法的直接引用，不然返回java.lang.IllegalAccessError异常；
3. 若是类型C中不存在对应的方法，则按照继承关系，从下往上依次对类型C的各父类进行搜索和验证，进行第2步的操做；
4. 若是各个父类也没对应的方法，则抛出异常AbstractMethodError；

invokevirtual和invokeinterface的区别

         虚函数表上的虚方法是按照从父类到子类的顺序排序的，所以对于使用invokevirtual调用的虚函数，JVM彻底能够在编译期就肯定了虚函数在方法表上的offset，或者在首次调用以后就把这个offset缓存起来，这样就能够快速地从方法表中定位所要调用的方法地址。         然而对于接口类型引用，因为一个接口能够被不一样的Class来实现，因此接口方法在不一样类的方法表的offset固然就（极可能）不同了。所以，每次接口方法的调用，JVM都会搜寻一遍虚函数表，效率会比invokevirtual要低。