jvm之方法调用过程

方法调用阶段的任务是确定要调用的方法的版本。class文件的编译与其他程序语言不同，它不包含连接步骤。class文件中存储的只是方法的符号引用。需要在类加载阶段（解析）或者运行时（委派）才能确定方法的直接引用。

一、解析

1.非虚方法

有一些方法在编译完成时就可以确定调用版本了。比如私有方法、静态方法、实例构造器、父类方法、被final修饰的方法，他们不会被子类重写，因此在编译期就可以确定要执行的版本。这类方法的调用被称为解析。

调用不同类型的方法，字节码指令集设计了不同的指令：

• invokestatic ：调用静态方法
• invokespecial ：调用<init>()、私有方法、父类方法
• invokevirtual ：调用虚方法
• invokeinterface ：调用接口方法
• invokedynamic ： 可以由用户程序决定调用哪个方法

静态方法、私有方法、实例构造器、父类方法以及被final修饰的方法（由invokevirtual调用）这五个方法在类加载阶段就可以解析为直接引用，这些方法被称为 非虚方法

2.静态分派

静态分派是指根据变量的静态类型决定调用方法的版本。这一步是在编译期完成的。

public class StaticDispatch {
	static abstract class Human {
	}
	static class Man extends Human {
	}
	static class Woman extends Human {
	}
	public void sayHello(Human guy) {
		System.out.println("hello,guy!");
	}
	public void sayHello(Man guy) {
		System.out.println("hello,gentleman!");
	}
	public void sayHello(Woman guy) {
		System.out.println("hello,lady!");
	}
	public static void main(String[] args) {
		Human man = new Man();
		Human woman = new Woman();
		StaticDispatch sr = new StaticDispatch();
		sr.sayHello(man);
		sr.sayHello(woman);
	}
}

运行结果

hello,guy!
hello,guy!

在这段代码中，Human是静态类型、Man和Woman是实际类型。在编译期间，编译器就根据静态类型把sayHello(Human) 符号引用写在了 invokevirtual的参数中。

二、动态分派

动态分派根据变量的实际类型调用方法。jvm通过invokevirtual实现动态分派。

这里objectref是实例对象的引用，也就是说invokevirtual要调用实际对象的方法。下面是invokevirtual的参数列表，要求操作数栈存放这些参数：

我们看下面这段代码：

class FieldHasNoPolymorphic {
    static class Father {
        public int money = 1;
        public Father() {
            money = 2;
            showMeTheMoney();
        }
        public void showMeTheMoney() {
            System.out.println("I am Father, i have $" + money);
        }
    }
    static class Son extends Father {
        public int money = 3;
        public Son() {
            money = 4;
            showMeTheMoney();
            fun();
        }
        public void showMeTheMoney() {
            System.out.println("I am Son, i have $" + money);
        }
        public void fun(){

        }
    }
    public static void main(String[] args) {
        Father gay = new Son();
        System.out.println("This gay has $" + gay.money);
    }
}

输出结果：

I am Son, i have $0
I am Son, i have $4
This gay has $2

执行过程：

1. Father gay = new Son();

对应字节码指令：

0: new           #2                  // class FieldHasNoPolymorphic$Son
3: dup
4: invokespecial #3                  // Method FieldHasNoPolymorphic$Son."<init>":()V

new指令分配内存并返回引用，然后用invokespecial调用Son.<init>()方法。
这里new返回的引用作为参数（objectref）给invokespecial。

2. 执行Son的构造方法

java代码：

        public Son() {
            money = 4;
            showMeTheMoney();
        }

对应字节码指令：

public FieldHasNoPolymorphic$Son();
  descriptor: ()V
  flags: ACC_PUBLIC
  Code:
    stack=2, locals=1, args_size=1
       0: aload_0
       1: invokespecial #1                  // Method FieldHasNoPolymorphic$Father."<init>":()V
       4: aload_0
       5: iconst_3
       6: putfield      #2                  // Field money:I
       9: aload_0
      10: iconst_4
      11: putfield      #2                  // Field money:I
      14: aload_0
      15: invokevirtual #3                  // Method showMeTheMoney:()V
	... ...
      LocalVariableTable:
        Start  Length  Slot  Name   Signature
            0      23     0  this   LFieldHasNoPolymorphic$Son;

先用invokespecial执行Father.<init>()方法。这里aload_0把局部变量表第0个变量加载到操作数栈并作为参数传递给Father.<init>()。

注意：java代码中Son的构造方法是没有参数的，但是在字节码文件中stack=2, locals=1, args_size=1 说参数数目为1。这个参数对应局部变量表中Name为this的变量，这个this是第1步中new指令创建的。也就是说第1步new返回的引用最终传给了Father.<init>()

3. 执行Father构造方法

Java代码：

        public Father() {
            money = 2;
            showMeTheMoney();
        }

对应字节码

public FieldHasNoPolymorphic$Father();
    descriptor: ()V
    flags: ACC_PUBLIC
    Code:
      stack=2, locals=1, args_size=1
         0: aload_0
         1: invokespecial #1                  // Method java/lang/Object."<init>":()V
         4: aload_0
         5: iconst_1
         6: putfield      #2                  // Field money:I
         9: aload_0
        10: iconst_2
        11: putfield      #2                  // Field money:I
        14: aload_0
        15: invokevirtual #3                  // Method showMeTheMoney:()V
        18: return
		... ...
	   LocalVariableTable:
	    Start  Length  Slot  Name   Signature
	        0      19     0  this   LFieldHasNoPolymorphic$Father;

标号14、15的字节码指令把this作为参数，用invokevirtual执行showMeTheMoney方法。

根据上面引用的虚拟机规范的描述，此时要调用this对应的类C也就是Son的方法。而 Son中的money变量仅仅在准备阶段赋为默认值0。所以第一行打印输出：

I am Son, i have $0

Father()执行完后，紧接着调用Son()，输出：

I am Son, i have $4

最后，在main方法中，直接输出Father的money变量：

This gay has $2