认识一下Java中方法重载和重写的“真面目”

前言

考大家一道题目，下面的类执行结果是什么？？？

public class DispatcherClient {

    public static void main(String[] args) {
        Animal a = new Animal();
        Animal a1 = new Dog();
        Animal a2 = new Cat();

        Execute exe = new Execute();
        exe.execute(a);
        exe.execute(a1);
        exe.execute(a2);
    }
}

 class Animal {
}

 class Dog extends Animal {
}

 class Cat extends Animal {
}

 class Execute {
    public void execute(Animal a) {
        System.out.println("Animal");
    }

    public void execute(Dog d) {
        System.out.println("dog");
    }

    public void execute(Cat c) {
        System.out.println("cat");
    }
}

不知道大家心里的答案是什么？反正我的答案是错的。

正确的答案是：

为什么是Animal Animal Animal？ 而不是Animal dog cat。

类重载本质——静态分派

execute方法是一个重载方法，本质上就是虚拟机JVM如何确定调用哪个方法执行。在java编译后的class文件中存储的只是方法的符号引用，而不是方法在实际运行过程中内存布局的入口地址（直接引用）。而这个方法从符号引用变成直接引用有两种方式，解析和分派。

解析是发生在类加载的解析阶段就会将一部分方法的符号引用转换为直接引用，比如类的静态方法、私有方法、构造方法、父类方法以及final的方法。我们这里不展开阐述，和本例无关。

而我们方法重载的情况下，java采用的是静态分派的方式确定调用方法。

变量类型

在了解静态分派前我们需要了解下变量的类型。

Animal a1 = new Dog();

• 静态类型, 也叫做”外观类型”, 比如代码中的”Animal”, 它的类型是在编译期就知道。
• 实际类型，也叫”运行时类型”, 比如代码中的”Dog”, 它是在类运行时才会确定，编译期是不知道的。

Execute exe = new Execute();
exe.execute(a);
exe.execute(a1);
exe.execute(a2);

这里多次调用了execute方法，在方法接收者已经确定是对象exe的前提下，使用哪个重载的方法，就完全取决于传入参数的数量和数据类型。虚拟机在重载时是通过参数的静态类型而不是实际类型作为判断依据的。因为静态类型是编译期可知的，所以，在编译阶段，编译器会根据静态类型决定使用哪个重载版本，如下图例子中的字节码，技术在编译的字节码中确定了它调用的重载方法。

类多态本质——动态分派

既然有静态分派，那么是不是有动态分派呢？什么又是动态派呢？

Java语言的一大特性是多态性，所谓多态就是指程序中定义的引用变量所指向的具体类型和通过该引用变量发出的方法调用在编程时并不确定，而是在程序运行期间才确定，即一个引用变量倒底会指向哪个类的实例对象，该引用变量发出的方法调用到底是哪个类中实现的方法，必须在由程序运行期间才能决定。

举个简单的例子，比如Human human = flag ? new Man() : new Woman(), human的具体类型是man还是woman在编写代码的时候我们是无法确定，它是由flag这个标记决定，只有在程序运行的时候才能够确定下来，这种让引用变量在运行时绑定到各种不同的类实现上，从而导致该引用调用的具体方法随之改变，即不修改程序代码就可以改变程序运行时所绑定的具体代码，让程序可以选择多个运行状态，这就是多态性。

多态在Java中有两种实现形式，分别是继承和接口，子类重写父类或者接口中的方法，现在举个例子。

public class DynamicDispatch {

    static abstract class Animal {
        protected abstract void eat();
    }

    static class Cat extends Animal {

        @Override
        protected void eat() {
            System.out.println("我吃鱼");
        }
    }

    static class Dog extends Animal {

        @Override
        protected void eat() {
            System.out.println("我吃骨头");
        }
    }

    public static void main(String[] args) {
        Animal cat = new Cat();
        Animal dog = new Dog();
        cat.eat();
        dog.eat();

        cat = new Dog();
        cat.eat();
    }
}

运行结果：

这个结果相信和大家想的是一致的，那大家有想过JVM是怎么找到具体的类型执行的呢？我们定义的引用类型就是Animal，JVM是根据什么来找到对应的Cat 或者Dog这些具体的实例执行对应的方法呢？

从字节码角度分析

利用idea的Jclasslib插件查看字节码：

1. 0~15行主要是创建Cat对象和Dog对象的字节码指令。
2. 17和21行一模一样，指令都是invokevirtual, 参数都是<com/alvin/chapter8/DynamicDispatch$Animal.eat。竟然这两条指令一模一样，那他是怎么确定调用哪个实际类型的方法呢？这还得要了解invokevirtual指令的运行过程：

• 找到操作数栈顶的第一个元素所指向的对象作为实际类型，记作类型C，这个是在运行期确定的。
• 如果在类型C中找到与常量中的描述符和简单名称都相符的方法，则进行访问权限校验，通过返回这个方法的直接引用，查过过程结束。
• 否则，按照继承关系从下往上依次对C的各个父类进行搜索和验证。
• 如果始终没有找到合适的方法，抛出AbstractMethodError异常。

1. 回过头来看，我们看到字节码中的第16行和20行的aload指令就是把刚刚创建的对象压入到栈顶。

以上的过程中根据方法接收者的实际类型来确定调用那个方法，找不到往父类继续找的过程，其实也就是重写的本质。我们把这种在运行期根据实际类型确定方法执行版本的分派过程叫做动态分派。

** 虚拟机动态分派的实现 **

上面讲述了虚拟即动态分派的过程，那它是怎么实现这一过程的呢？

因为动态分派是执行非常频繁的动作，而且需要在运行时搜索合适的目标方法，基于性能的考虑，java虚拟机采用了一种基础且常见的优化手段—为类型在方法区建立一个需方法表。使用需方法表索引来代替元数据查找以提高性能。

虚方法表中存放着各个方法的实际入口地址。如果某个方法在子类中没有被重写，那子类的虚方法表中的地址入口和父类相同方法的地址入口时一致的，如果子类重写了方法，子类虚方法表中的地址会被替换为指向子类实现版本的入口地址。

总结

总结下，所有依赖静态类型来定位方法执行版本的分派叫做静态分派。静态分派的典型应用就是方法重载，它是在编译阶段确定的，它会选择一个最合适的版本方法进行调用。而动态分派简单来说就是根据变量的动态类型确定执行哪个方法，典型的应用就是方法的重写。