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();
}

·········
········
·······
····
···
·
··
··
·
·
·
·

·
··
·
·
··
·
·
·
·
·
·
·
·
·
·
·
·
·
·
·
··
·
·
输出：
Animal Test
Animal
Person
Person Test
Animal
Person

你猜对了吗？

Tips
在覆盖(重写)一个方法的时候，子类方法不能低于父类方法的可见性。