java多态性

1.定义

不同的对象对同一消息的不同响应

2.多态性有两种

1）编译时多态性
对于多个同名方法,如果在编译时能够确定执行同名方法中的哪一个,则称为编译时多态性.
2）运行时多态性
如果在编译时不能确定,只能在运行时才能确定执行多个同名方法中的哪一个,则称为运行时多态性.

3.必要条件

1）继承：有继承关系的子类和父类

2）重写：子类对父类中某些方法进行重新定义

3）父类引用指向子类对象：向上转型

4.实现方式

继承父类或实现接口

5.特征

1）强制的：一种隐式做类型转换的方法
2）重载的：将一个标志符用作多个意义
3）参数的：为不同类型的参数提供相同的操作
4）包含的：类包含关系的抽象操作

6.执行顺序

(1) 首先, 要明确子类对父类发生了方法的重载还是重写，根据参数类型及个数； 
(2) 如果是重载，则子类继承了父类的方法，相当于子类多加了父类的方法； 
(3) 如果是重写， 则子类类不会有父类的该方法，而是把该方法重写了，所以该方法存在于父类中，子类只是重写了。要想调用父类的该方法，只能通过super关键字调用。 java 的这种机制遵循一个原则：当超类对象引用变量引用子类对象时，被引用对象的类型而不是引用变量的类型决定了调用谁的成员方法，但是这个被调用的方法必须是在超类中定义过的，也就是说被子类覆盖的方法；
(4) 接下来，观察方法执行时的参数类型； 
(5) 然后看调用对象的声明类型和实例类型； 
(6) 方法的调度采用最精确参数匹配。

7.例子

摘自：http://blog.csdn.net/thinkGhoster/archive/2008/04/19/2307001.aspx。

[java]  view plain  copy

 print ?

1. public class A {  
2.     public String show(D obj) {  
3.         return ("A and D");  
4.     }  
5.   
6.     public String show(A obj) {  
7.         return ("A and A");  
8.     }   
9.   
10. }  
11.   
12. public class B extends A{  
13.     public String show(B obj){  
14.         return ("B and B");  
15.     }  
16.       
17.     public String show(A obj){  
18.         return ("B and A");  
19.     }   
20. }  
21.   
22. public class C extends B{  
23.   
24. }  
25.   
26. public class D extends B{  
27.   
28. }  
29.   
30. public class Test {  
31.     public static void main(String[] args) {  
32.         A a1 = new A();  
33.         A a2 = new B();  
34.         B b = new B();  
35.         C c = new C();  
36.         D d = new D();  
37.           
38.         System.out.println("1--" + a1.show(b));  
39.         System.out.println("2--" + a1.show(c));  
40.         System.out.println("3--" + a1.show(d));  
41.         System.out.println("4--" + a2.show(b));  
42.         System.out.println("5--" + a2.show(c));  
43.         System.out.println("6--" + a2.show(d));  
44.         System.out.println("7--" + b.show(b));  
45.         System.out.println("8--" + b.show(c));  
46.         System.out.println("9--" + b.show(d));        
47.     }  
48. }  

      运行结果：

[java]  view plain  copy

 print ?

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

      在这里看结果1、2、3还好理解，从4开始就开始糊涂了，对于4来说为什么输出不是“B and B”呢？

      首先我们先看一句话：当超类对象引用变量引用子类对象时，被引用对象的类型而不是引用变量的类型决定了调用谁的成员方法，但是这个被调用的方法必须是在超类中定义过的，也就是说被子类覆盖的方法。这句话对多态进行了一个概括。其实在继承链中对象方法的调用存在一个优先级：this.show(O)、super.show(O)、this.show((super)O)、super.show((super)O)。

      分析：

      从上面的程序中我们可以看出A、B、C、D存在如下关系。

      首先我们分析5，a2.show(c)，a2是A类型的引用变量，所以this就代表了A，a2.show(c),它在A类中找发现没有找到，于是到A的超类中找(super)，由于A没有超类（Object除外），所以跳到第三级，也就是this.show((super)O)，C的超类有B、A，所以(super)O为B、A，this同样是A，这里在A中找到了show(A obj)，同时由于a2是B类的一个引用且B类重写了show(A obj)，因此最终会调用子类B类的show(A obj)方法，结果也就是B and A。

      按照同样的方法我也可以确认其他的答案。

      方法已经找到了但是我们这里还是存在一点疑问，我们还是来看这句话：当超类对象引用变量引用子类对象时，被引用对象的类型而不是引用变量的类型决定了调用谁的成员方法，但是这个被调用的方法必须是在超类中定义过的，也就是说被子类覆盖的方法。这我们用一个例子来说明这句话所代表的含义：a2.show(b)；

      这里a2是引用变量，为A类型，它引用的是B对象，因此按照上面那句话的意思是说有B来决定调用谁的方法,所以a2.show(b)应该要调用B中的show(B obj)，产生的结果应该是“B and B”，但是为什么会与前面的运行结果产生差异呢？这里我们忽略了后面那句话“但是这儿被调用的方法必须是在超类中定义过的”，那么show(B obj)在A类中存在吗？根本就不存在！所以这句话在这里不适用？那么难道是这句话错误了？非也！其实这句话还隐含这这句话：它仍然要按照继承链中调用方法的优先级来确认。所以它才会在A类中找到show(A obj)，同时由于B重写了该方法所以才会调用B类中的方法，否则就会调用A类中的方法。

      所以多态机制遵循的原则概括为：当超类对象引用变量引用子类对象时，被引用对象的类型而不是引用变量的类型决定了调用谁的成员方法，但是这个被调用的方法必须是在超类中定义过的，也就是说被子类覆盖的方法，但是它仍然要根据继承链中方法调用的优先级来确认方法，该优先级为：this.show(O)、super.show(O)、this.show((super)O)、super.show((super)O)。