从底层剖析java多态（向上转型和动态绑定）

多态是什么

我们先来看一下菜鸟教程中对多态的解释

多态是同一个行为具有多个不同表现形式或形态的能力。
多态就是同一个接口，使用不同的实例而执行不同操作
现实中，比如我们按下 F1 键这个动作：
如果当前在 Flash 界面下弹出的就是 AS 3 的帮助文档；
如果当前在 Word 下弹出的就是 Word 帮助；
在 Windows 下弹出的就是 Windows 帮助和支持。
同一个事件发生在不同的对象上会产生不同的结果。
多态的优点

1. 消除类型之间的耦合关系
2. 可替换性
3. 可扩充性
4. 接口性
5. 灵活性
6. 简化性

多态存在的三个必要条件
1.继承
2.重写
3.父类引用指向子类对象

多态的具体实现

相信大家看完上面的部分就会对多态有一点了解，下面我用具体的代码来为大家详细解释

public class Test_1 {
	public static void main(String[] args) {
		Person stu = new Student();
		prints(new Person());
		prints(new Student());
		prints(new Worker());
		
	}
	
	public static void prints(Person p) {
		p.eat();
		p.rest();
	}

}

class Person{
	String name;
	int age;
	public static void rest() {
		System.out.println("------正在休息----------");
	}
	public void eat() {
		System.out.println("------正在吃饭----------");
	}
	public void sleep() {
		System.out.println("------正在睡觉----------");		
	}
	
}

class Student extends Person{
	public static void rest() {
		System.out.println("------学生正在休息----------");
	}
	//重写父类的eat()方法
	public void eat() {
		System.out.println("------学生正在吃饭----------");
	}
	//定义子类特有的study()方法
	public void study() {
		System.out.println("------正在学习----------");
	}
}
class Worker extends Person{
	public static void rest() {
		System.out.println("------工人正在休息----------");
	}
	
	//重写父类的eat()方法
	public void eat() {
		System.out.println("------工人正在吃饭----------");
	}
	//定义子类特有的work()方法
	public void work() {
		System.out.println("------正在工作----------");
	}
}

运行结果：

这段代码就是一个多态的体现，我们连续调用三次prints()，prints函数调用的都是同样的方法eat()和静态方法rest()，但是却eat()方法输出了三次不同的结果，而rest()方法三次都输出的一样的结果。这就是因为我们函数的形参定义的是一个Person，所以我们只要传递他的子类，都会自动向上转型为Person类，但是因为我们new的是一个子类对象，所以在内存中实质上开辟的是一个子类的空间，因此我们调用的是子类重写过的方法，而静态方法无法被重写，所以也就不会调用子类的方法。但是如果我们想调用子类特有的方法，如study和work时，编译器就会报错，这有啥为什么呢？

当然这只是表面上的理解，因此无法解释最后一个问题，下面从java运行机制方面来对其进行解释

静态绑定和动态绑定

这就要涉及java中的动态绑定了

首先先来看一下什么是绑定

程序绑定的概念：

绑定指的是一个方法的调用与方法所在的类(方法主体)关联起来。对java来说，绑定分为静态绑定和动态绑定；或者叫做前期绑定和后期绑定
　　
　　静态绑定：
　　在程序执行前方法已经被绑定，此时由编译器或其它连接程序实现。例如：C。
　 针对java简单的可以理解为程序编译期的绑定；这里特别说明一点，java当中的方法只有final，static，private和构造方法是前期绑定

动态绑定：在运行时根据具体对象的类型进行绑定。

若一种语言实现了动态绑定，同时必须提供一些机制，可在运行期间判断对象的类型，并分别调用适当的方法。也就是说，编译器此时依然不知道对象的类型，但方法调用机制能自己去调查，找到正确的方法主体。不同的语言对后期绑定的实现方法是有所区别的。但我们至少可以这样认为：它们都要在对象中安插某些特殊类型的信息。

动态绑定的过程：

虚拟机提取对象的实际类型的方法表；

虚拟机搜索方法签名；

调用方法。

因此，虽然我们开辟的是一个子类的空间，但在运行阶段java查的是父类的方法表，父类方法表中没有的方法自然不会去找，在查找的时候也会从最下面开始找，也就是从子类那里开始找，如果子类中找到了，就不会找下去了，而static，final，private方法由于是静态绑定，也就是在编译器就已经绑定了它的类型是Person类，所以就不会从子类开始找，而是直接从父类Person的空间中去找。