方法调用并不等同于方法执行，方法调用阶段唯一的任务就是确定被调用方法的版本，暂时还不涉及方法内部的具体运行过程。
解析
所有方法调用中的目标方法在Class文件里面都是一个常量池中的符号引用，在类加载的解析阶段，会将其中的一部分符号引用转化为直接引用，这种解析能成立的前提是：方法在程序真正运行之前就有一个可确定的调用版本，并且这个方法的调用版本在运行期是不可改变的。换句话说，调用目标在程序代码写好、编译器进行编译时就必须确定下来。这类方法的调用称为解析。
与之相对应的是，在Java虚拟机里面提供了5条方法调用字节码指令，分别如下：
- invokestatic：调用静态方法。
- invokespecial：调用实例构造器<init>方法、私有方法和父类方法。
- invokevirtual：调用所有的虚方法。
- invokeinterface：调用接口方法，会在运行时确定一个实现此接口的对象。
- invokedynamic：现在运行时动态解析出调用点限定符所引用的方法，然后再执行该方法，在此之前的4条调用指令，分派逻辑是固化在Java虚拟机内部的，而invokedynamic指令的分派逻辑是由用户所设定的引导方法决定的。
/**
*方法静态解析演示
*/
public class StaticResolution{
public static void sayHello(){
System.out.println("hello world");
}
public static void main(String[] args){
StaticResolution.sayHello();
}
}
-------------------------
D：\Develop\＞javap-verbose StaticResolution
public static void main（java.lang.String[]）；
Code： Stack=0，Locals=1，Args_size=1
0：invokestatic#31；//Method sayHello：（）V
3：return LineNumberTable：
line 15：0
line 16：3
Java 中的非虚方法除了使用invokestatic、invokespecial调用的方法之外还有一种，就是被final修饰的方法。虽然final方法是使用ivokevirtual指令来调用的，但是由于它无法被覆盖，没有其他版本，所以也无需对方法接收这进行多态选择，又或者说多态选择的结果肯定是唯一的。
分派
1. 静态分派
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”称为变量的静态类型（Static Type），或者叫做外观类型（Apparent Type），后面的“Man”则称为变量的时机类型（Actual Type），静态类型和时机类型在程序中都可以发生一些变化，区别是静态类型的变化仅仅在使用时发生，变量本身的静态类型不会被改变，并且最终的静态类型是在编译期克制的；而实际类型变化的结果在运行期才可确定，编译器在编译程序的时候并不知道一个对象的时机类型是什么。
2. 动态分派
动态分派，它和多态性的另一个重要体现---重写（Override）。
/**
*方法动态分派
*/
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();
Huamn woman=new Woman();
man.sayHello();
woman.sayHello();
man=new Woman();
man.sayHello();
}
}
--------
输出结果：
man say hello
woman say hello
woman say hello
3. 单分派与多分派
方法的接收者与方法的参数统称为方法的宗量。根据分派基于多少种总量，可以将分派划分为单分派和多分派两种。单分派是根据一个宗量对目标方法进行选择，多分派则是根据多余一个宗量对目标方法进行选择。编译期间编译器的选择称为静态分派是多分派，运行期间虚拟机的选择称为动态分派是单分派。
单分派和多分派
/**
*单分派、多分派
*/
public class Dispatch{
static class QQ{}
static class _360{}
public static class Father{
public void hardChoice(QQ arg){
System.out.println("father choose qq");
}
public void hardChoice(_360 arg){
System.out.println("father choose 360");
}
}
public static class Son extends Father{
public void hardChoice(QQ arg){
System.out.println("son choose qq");
}
public void hardChoice(_360 arg){
System.out.println("son choose 360");
}
}
public static void main(String[]args){
Father father=new Father();
Father son=new Son();
father.harChoice(new _360());
son.hardChoice(new QQ());
}
}
---------
执行结果：
father choose 360
son choose qq
在编译阶段编译器的选择过程，也就是静态分派的过程。这时选择目标方法的依据有两点：一是静态类型是Father还是Son，二是方法参数是QQ还是360.这次选择的最终产物是产生两条invokevirtual指令，这两条指令的参数分别为常量池中指向Father.hardCHoice(360)及Father.hardChoice(QQ)方法的符号引用。因为是根据两个宗量进行选择，所以Java语言的静态分派属于多分派类型。
运行阶段虚拟机的选择，动态分派的过程。在执行“son.hardChoice(new QQ())”这句代码时，更准确地说，是在执行这句代码所对应的“invokevirtual”指令时，由于编译器已经决定目标签名必须为hardCHoice(QQ),虚拟机此时不会关心传递过来的参数“QQ”到底是“TX QQ”还是"奇瑞QQ".因为这时参数的静态类型、世纪类型都对方法的选择不会构成任何影响，唯一可以影响虚拟机选择的因素只有此方法的接受者的时机类型是Father还是Son，因为只有一个宗量作为选择依据。所以Java语言的动态分派属于单分派类型。
4. 虚拟机动态分派的实现
虚方法表中存放着各个方法的时机入口地址。如果某个方法在子类中没有被重写，那么子类的虚方法表里面的地址入口和父类相同方法的地址入口是一致的，都指向父类的实现入口。如果子类重写了这个方法，子类方法表中的地址将会替换为指向子类实现版本的入口地址。具有相同签名的方法，在父类、子类的虚方法表中都应当具有一样的索引序号，这样当类型变换时，仅需要变更查找的方发表，就可以从不同的需方法表中按索引转换出所需的入口地址。
动态语言与静态语言的区别
静态语言在编译期确定类型，最显著的好处是编译器可以提供严谨的类型检查，这样与类型相关的问题能在编码的时候就即使发现，利于稳定性及代码达到更大规模。而动态类型语言在运行期确定类型，这可以为开发人员提供更大灵活性，某些静态语言中需用大量“臃肿”代码来实现的功能，由动态类型语言来实现可能会更加清晰和简洁。
基于栈的字节码解释执行引擎
基于栈的指令集与基于寄存器的指令集
Java编译器输出的指令流，基本上是一种基于栈的指令集架构（Instruction Set Architecture，ISA）指令流中的指令大部分都是零地址指令，他们一来操作数栈进行工作。与之相对的另外一套常用的指令集结构是基于寄存器的指令集，最典型的就是x86的二地址指令集，说的通俗一些，就是现在我们主流PC机中直接支持的指令集架构，这些指令依赖寄存器进行工作。
