java多态详解

java的三大特性：

                 继承，封装，多态

     其中多态是这三大特性中比较难理解的，封装和继承几乎都是为多态而准备的。

  一、 什么是多态？多态的定义：

 指允许不同类的对象对同一请求做出响应，也就是同一请求可以根据发送对象的不同而采用的多种不同的行为方式。

      二、多态存在的三个必要条件：

  1、要有继承；

  2、要有重写；

  3、父类引用子类对象；

  三、为什么需要使用多态？多态的好处？

1、可以增强程序的可扩展性及可维护性，使代码更加简洁。

2、能减少编码的工作量，也能大大提高程序的可维护性及可扩展性。

四、如何实现多态？

一般做法是：写一个方法，它只接收父类作为参数，编写的代码只与父类打交道。调用这个方法时，实例化不同的子类对象（new一个对象）。更具体的说:

1、子类重写父类的方法。使子类具有不同的方法实现。

2、把父类类型作为参数类型，该父类及其子类对象作为参数转入。

3、运行时，根据实际创建的对象类型动态决定使用那个方法。在运行时，java虚拟机会根据实际创建的对象类 型决定使用那个方法。一般将 这称为动态绑定。

五、Java中多态的实现方式：接口实现，继承父类进行方法重写，同一个类中进行方法重载。

经典实例。

  通过上面的讲述，可以说是对多态有了一定的了解。现在趁热打铁，看一个实例。该实例是有关多态的经典例子，摘自：http://blog.csdn.net/thinkGhoster/archive/2008/04/19/2307001.aspx。

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. }  

运行结果：

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)。

  参考资料：http://blog.csdn.net/thinkGhoster/archive/2008/04/19/2307001.aspx。

  百度文库：http://wenku.baidu.com/view/73f66f92daef5ef7ba0d3c03.html