Java中的多态性

Java有三大特性：封装、继承和多态

所谓多态就是指有多个状态，比如“食物”这个概念，它可以是肉、鱼和蔬菜，因此“食物”具有多态性。在程序的运行时有多个状态，也就是父类的引用变量被哪个子类所实例化，这就是向上转型。多态实现的三个必要条件：继承、重写、向上转型。

继承：继承就是一个父类有多个子类，比如一个Food类可以有Meet类和Fish类。

重写：重写很关键，就是子类中必须重写父类的方法，这样在向上转型后的调用中才能调用不同子类中的方法。

向上转型：父类的引用变量被子类所实例化，如Food f = new Meet。向上转型会造成一些方法和属性的丢失，他可以调用所有父类中的的属性和方法，但不能调用只存在于子类中的类型和方法。

【1】多态的使用规则

【2】基于继承的多态

【3】基于接口的多态

【4】多态的扩展

多态的使用规则

子类的父类引用向上转型，只能访问父类的属性和方法，不能访问只存在于子类的方法，重载也不可以，必须重写才可以调用子类中方法和属性，（重载是返回相同，参数个数不同。重写是返回和参数都相同）也就是子类中重写了父类中的方法时，调用时肯定调用子类中的方法。

基于继承的多态

基于继承的多态表现为一个或者多个子类对父类方法的重写，子类对象向上转型之后可以调用子类中这些重写的方法。下面是基于继承的例子：

package TwoWeek;

public class Extend1{
public static void main(String args[]){
Food f1 = new Food();
f1.Eat();
Food f2 = new Meet();
f2.Eat();
Food f3 = new Fish();
f3.Eat();
//f3.HaveBone();// 使用Food中没有的方法会出错
}
}

class Food{
Food(){
System.out.println("这是Food的构造方法");
}
public void Eat(){
System.out.println("吃食物");
}
}

class Meet extends Food{
public void Eat(){
System.out.println("我们逮肉");
}
}

class Fish extends Food{
public void Eat(){
System.out.println("我们吃鱼");
}

public void HaveBone(){
System.out.println("鱼是有刺的");
}
}

输出结果为：

这是Food的构造方法
吃食物
这是Food的构造方法
我们逮肉
这是Food的构造方法
我们吃鱼

在向上转型的之后，调用各自子类中的Eat()方法。

基于接口的多态

接口的多态和集成的多态是相似的，用几个不同的类来实现接口并覆盖接口中的同一方法，继承只有单继承，而接口不同，可以实现多继承，所以其有更高的灵活性。

package TwoWeek;

public class Extend2{
public static void main(String args[]){
Meet1 f2 = new Meet1();
f2.Eat();
Fish1 f3 = new Fish1();
f3.Eat();
f3.HaveBone();// 我们发现这个是可以不会报错的
}
}

interface Food1{
public void Eat();
}

class Meet1 implements Food1{
public void Eat(){
System.out.println("我们逮肉");
}
}

class Fish1 implements Food1{
public void Eat(){
System.out.println("我们吃鱼");
}

public void HaveBone(){
System.out.println("鱼是有刺的");
}
}

输出结果为：

<span style="font-size:18px;">这是Food的构造方法
吃食物
这是Food的构造方法
我们逮肉
这是Food的构造方法
我们吃鱼</span><span style="color:#3333ff;font-size:24px; font-weight: bold;">
</span>

多态的扩展
当父类对象的引用变量引用子类对象时，被应用对象而不是引用变量决定了调用谁的成员方法，但是这边被调用的方法是在子类中定义过的，也就是被子类重写的方法，根据调用链中调用方法的优先级来确认方法。下面是引用自大神博客http://blog.csdn.net/chenssy/article/details/12786385的经典继承例子：

public class A {
public String show(D obj) {
return ("A and D");
}

public String show(A obj) {
return ("A and A");
}

}

public class B extends A{
public String show(B obj){
return ("B and B");
}

public String show(A obj){
return ("B and A");
}
}

public class C extends B{

}

public class D extends B{

}

public class Test {
public static void main(String[] args) {
A a1 = new A();
A a2 = new B();
B b = new B();
C c = new C();
D d = new D();

System.out.println("1--" + a1.show(b));
System.out.println("2--" + a1.show(c));
System.out.println("3--" + a1.show(d));
System.out.println("4--" + a2.show(b));
System.out.println("5--" + a2.show(c));
System.out.println("6--" + a2.show(d));
System.out.println("7--" + b.show(b));
System.out.println("8--" + b.show(c));
System.out.println("9--" + b.show(d));
}
}

输出结果为：

1--A and A
2--A and A
3--A and D
4--B and A
5--B and A
6--A and D
7--B and B
8--B and B
9--A and D

确实是从第四个开始就迷糊了，下面来捋一捋。

下面我们来分析第四个a2.show(b)，其中a2是A类型的引用变量，也就是父类中的引用变量，引用的是B类型的对象，也就是应该调用b类中的show(B obj)方法，出现"B and B"的结果，当不能忘了一件事，该show()方法必须在类中也存在且被子类覆写才可以，但是父类中没有存在。那就只能按照继承链总的的调用优先级来执行了，优先级是这样的（this.show(O)、super.show(O)、this.show((super)O)、super.show((super)O)）所有才会在A类中找到show(A
obj)，又因为B类中覆写了show(A obj)，所以最终调用B类中的方法。

在分析一下第五个，便于加深理解，a2.show(c)，a2是A类型，所以this = A，因为引用的也是B类型对象，所以首先也在B里边找，没有找到。然后到this也就是A里边找，发现又没有找到，然后按照规定就到A的super类里边找，但是A没有超类，那就按照第三继承规则this.show((super)O)，C的超类为A，且this是A，所以a.show(a)，有因为B中覆写了它，所以结果还是B
and A.