读书笔记JVM探秘之五：字节码执行引擎（重载+重写原理）

虚拟机是基于栈的体系结构，字节码执行依靠栈来操作。

栈

虚拟机中有两种栈，虚拟机栈（运行栈）和操作数栈，前者线程私有，作为运行方法的载体，以栈帧为单位；后者在栈帧中，每个栈帧带有一个操作数栈，作为执行字节码的载体。

栈帧

一个方法在运行栈中被表达成一个栈帧，栈顶帧为当前执行方法，它的大小在编译期就被完全确定（其他体系结构的栈帧也是这样的）。

栈帧结构

1、局部变量表，存储参数列表、局部（临时）变量，以slot为单位，slot大小不确定，不同的虚拟机有不同的实现，但可以确定的是它是可重用的，像c的共用体一样（union），这点可以通过局部变量的作用域计算。同样的局部变量表的大小在编译期就被完全确定了。
2、操作数栈，VM最核心的部分，最大深度（容量）在编译期被确定，不可改变。4字节所占栈容量为1，8字节就是2，当方法开始执行时它是空的。字节码依靠操作数栈来执行，同时伴随着大量的出站入站操作。
3、动态链接，每个栈帧都包含一个指向运行时常量池中该栈帧所述方法的引用，这涉及到方法符号引用的动态解析。
4、返回地址，这个字面意思。
5、附加信息，一些额外的内容，谁知道是什么鬼=。=
PS：一、JAVA方法只可能有两种退出方式，一是正常退出，一是异常得不到处理导致退出。
二、引用类型的长度没有明确规定但大都32位（就像C中的指针一样），但它的作用却被明确规定，有两点： 其一通过引用必须找到堆中对象实例的起始地址；其二能够找到方法区中对象所属数据类型的信息。

方法调用

应该把方法调用和方法运行分成两个阶段看，因为JAVA在运行方法之前并不知道要运行方法的哪个版本（这里指重写，重载不在这里确定）。

方法重载

对于重载，有一段非常有意思的代码：

package test;

/**
 * Created by Lee Y on 2016/5/3.
 */
public class MethodOverload {
    static class Shape{

    }
    static class Circle extends Shape{

    }
    static class Triangle extends Shape{

    }
    public void print(Shape arg){
        System.out.println("This is a simple shape.");
    }
    public void print(Circle arg){
        System.out.println("This is a circle.");
    }
    public void print(Triangle arg){
        System.out.println("This is a triangle.");
    }

    public static void main(String[] args) {
        Shape s = new Shape();
        Shape c = new Circle();
        Shape t = new Triangle();
        Circle circle = new Circle();
        Triangle triangle = new Triangle();
        MethodOverload m = new MethodOverload();
        m.print(s);
        m.print(c);
        m.print(t);
        m.print(circle);
        m.print(triangle);
    }
}
/* OUTPUT
This is a simple shape.
This is a simple shape.
This is a simple shape.
This is a circle.
This is a triangle.
*/

答案已附上，重载区别于重写的地方有很多。这里先摆明两个定义，变量的声明类型称为静态类型，而new出来的类型称为实际类型，对于Shape c = new Circle(); shape是c的静态类型，circle是c的实际类型。重载看的是前者，也就是静态类型，当然重载还取决于参数列表的长度和顺序（不取决于返回值！）。
静态类型在编译期可知，方法重载也在编译期确定，也就是在编译成class文件的时候方法重载的版本就确定了。方法重载的过程被称为静态分派，由于重载取决于多种因素，因此又叫静态多分派。

方法重写

package test;

/**
 * Created by Lee Y on 2016/5/3.
 */
public class MethodOverwrite {
    public static void main(String[] args) {
        A a = new A();
        A b = new B();
        A c = new C();
        A d = new D();
        a.print();
        b.print();
        c.print();
        d.print();
    }
}
class A{
    public void print(){
        System.out.println("AAAAAA");
    }
}
class B extends A{
    @Override
    public void print() {
        System.out.println("BBBBBB");
    }

}
class C extends B{
    @Override
    public void print() {
        System.out.println("CCCCCC");
    }
}
class D extends C{

}
/*OUTPUT
AAAAAA
BBBBBB
CCCCCC
CCCCCC
*/

如上面代码所示，重写取决于变量的实际类型，且仅仅取决于实际类型。这种在运行时才确定方法调用版本的过程称为动态分派，方法重写属于动态单分派，那么动态多分派就属于动态语言的范畴了吧？
综上所述，方法调用应该先经过编译期确定重载版本，运行时确定重写版本才能最终确定。重载在同一类空间中起作用，重写在继承关系上起作用。