Java多态性浅析

前言

今天我们要讲的是 Java的三大特性之一—多态性，而讲到多态，就不能不提与之息息相关的另一个概念—动态绑定。我们先看一下定义：一个对象变量可以指示多种实际类型的对象被称为多态(polymorphism)。在运行时能够自动地选择调用哪个方法的现象称为动态绑定(dynamic binding)。动态绑定是多态的技术实现。

在Java中实现多态的方式：
1. 实现接口
2. 继承父类，重写方法
3. 方法重载

简而言之：父类(接口)引用指向子类对象，子类重写父类方法。

这样做的好处显而易见，将方法的具体实现交给子类来做，父类/接口不必关心到底是哪个子类、如何实现，使方法更有兼容性。我们查看JDK源码或者一些框架的源码就会发现这一点。举个简单地例子：Servlet的init()和destroy方法、Spring的ApplicationContextAware接口的setApplicationContext(ApplicationContext)方法。Servlet和SpringMVC的初始化及请求处理过程浅析

我们来看个简单的例子

public class Fruit {
    public void print(){
        System.out.println("Fruit");
    }
    protected void test() {
        System.out.println("test fruit");
    }
}
public class Apple extends Fruit {
    @Override
    public void print() {
        System.out.println("Apple");
    }
    @Override
    public void test() {
        System.out.println("test apple");
    }
}
public class Banana extends Fruit {
    @Override
    public void print() {
        System.out.println("Banana");
    }
    @Override
    public void test() {
        System.out.println("test banana");
    }
}

public static void main(String[] args) {
    Fruit[] fruits = new Fruit[3];
    fruits[0] = new Fruit();
    fruits[1] = new Apple();
    fruits[2] = new Banana();

    for (Fruit fruit : fruits) {
        fruit.print();
    }
}

这个例子很简单，父类数组接收子类对象作为元素，没毛病。我想输出结果大家也都能猜到：
Fruit
Apple
Banana
但是原理是什么呢？对于这个原理我看到过很多版本，有的人说 子类方法覆盖了父类方法，有人说这是Java的动态绑定，自动搜索到应该执行的方法，我上大学时，老师这样跟我解释”调用的实际上还是父类的方法，只是子类的方法地址上传到了父类方法的入口，覆盖掉了父类方法”，众说纷纭，不一而足。
我们先不说谁对谁错，反正我是以老师的说法为标准答案好几年，直到我看到了《Core Java》里面的解释。。。

动态绑定的原理和调用过程分析
1. 编译器查看对象的声明类型和方法名。假设调用x.f(param)，且隐式参数x的声明类型(即实际类型)为C，那么编译器会一一列举C类中的所有的名为f的方法和其父类中的public且名为f的方法(父类的私有方法不可访问)。至此，编译器一伙的所有可能被调用的候选方法。
2. 编译器将查看调用方法时提供的参数类型。我们知道唯一确定一个方法的特征叫做方法签名，方法名称+参数类型和个数决定了一个参数，方法名相同、参数不同的叫做方法重载，编译器通过方法名和参数查找方法的过程叫做重载解析。如果编译器没有找到对应的方法或者找到多个对应的方法，编译器会报错。
3. 如果是private方法(子类不能继承，所以不存在重写)、static方法(类方法，与实例对象无关)、final方法(被final修饰的方法子类不可重写)，那么编译器可以明确地知道应该调用哪个方法，这种调用方式成为静态绑定。
4. 使用动态绑定调用方法时，虚拟机一定先查找对象x所引用的实际类型中方法签名匹配的方法，如果实际类型中不存在，则会查找父类，以此类推向上查找。

看到这里我们就能明白为什么会有多态性和动态绑定的原理了，但是如果调用一个方法要以这样的过程来查找方法的话，效率实在低下，那么有没有更加高效的方法呢？ 那肯定是有的：
方法表
如果看过《JVM内存结构》，那么我们会知道，一个类在被ClassLoader加载到VM中的过程中，就会在线程共享区，生成这个类的一系列的共享数据：常量池、静态变量、ClassLoader和Class的引用、字段、方法信息等等，其中这个方法信息就是我们要讲的类的方法表。
方法表列出了所以的方法的签名和实际调用的方法，这样在真正调用方法的时候，虚拟机仅需查找这个表就行了。
对于上面的例子，我们来分析一下类的方法表组成。
Fruit：
print()–>Fruit.print()
test()—>Fruit.test()
toString—>Object.toString()
….省略继承自Object其他的方法

Apple：
print()—>Apple.print()、Fruit.print()
test()—>Apple.test()、Fruit.test()
toString()—>Object.toString()
….省略继承自Object其他的方法

好了，经过以上的分析，我想大家都已明白和掌握了多态性和动态绑定的实现原理，那么我们下面来看另一段代码，并分析猜测一下输出结果。(如果你还未明白上面的，请继续理解。)

子类和父类的代码

package model;
/**
 * @author rambo.pan
 * 2016年8月26日
 */
public class Animal {
    private int age;

    public void print(){
        System.out.println("Animal");
    }

    public void test(){
        System.out.println("Animal Test");
        print();
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

}

package model;

public class Person extends Animal{
    private int age;
    private String name;

    @Override
    public void print() {
        super.print();
        System.out.println("Person");
    }


    @Override
    public void test() {
        super.test();
        System.out.println("Person Test");
        print();
    }
    public Person(int age, String name) {
        this.age = age;
        this.name = name;
    } 

    public Person(){
    }

    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }

    @Override
    public String toString() {
        return "Person [age=" + age + ", name=" + name + "]";
    }



}

Test：

public static void main(String[] args) {
        Animal animal = new Person();
        animal.test();
}