多态的理解

1、定义：在程序中定义的某个引用变量具体所指向的类型和调用的方法在编码时并不能确定，而只有在运行的时候才能确定。

 

2、简单理解：你定义的引用变量是父类型，而你创建的对象是子类型，用这个父类型的引用变量指向这个子类型的对象，然后当你调用这个对象的方法的时候，具体是调用的父类的还是子类的方法只有在运行的时候才能确定，可能调用的是父类的方法也有可能调用的子类的方法，这样不用修改代码，就可以让成徐选择多个运行的状态，这就是多态。

 

3、要点：

 

    1）多态的三大必要条件：继承、覆写、父类引用指向子类对象。

    2）父类的实例方法可以被覆盖，属性不能被覆盖。

    3）父类的引用可以访问父类的所有属性和方法，可以访问子类覆盖的方法（引用指向子类对象的话），但不能访问子类的属性（属性不能被覆盖），及子类新添加的方法。

    4）父类引用会调用子类覆盖的方法即动态绑定，指定是程序在执行时（非编译期间）会判断引用对象的实际类型，并调用其相应的方法。

 

4、关于在集合中使用泛型及多态的问题

 

先看下以下代码能否通过编译？

    实例一： 

Java代码  

1. package com.linwei;  
2. import java.util.ArrayList;  
3. import java.util.List;  
4.   
5. abstract class Animal {  
6.     public void eat(){  
7.         System.out.println("animal eating");  
8.     }  
9. }  
10.   
11. class Dog extends Animal{  
12.     public void bark(){  
13.         System.out.println("dog barking");  
14.     }  
15. }  
16.   
17. class Cat extends Animal{  
18.     public void meow(){  
19.         System.out.println("cat meowing");  
20.     }  
21. }  
22.   
23. public class TestDuotai {  
24.     public void showAnimals(List<Animal> animals ){  
25.         //animals.add(new Cat());   
26.         for(Animal a : animals){  
27.             a.eat();  
28.         }  
29.     }  
30.       
31.     public static void main(String[] args) {  
32.         ArrayList<Dog> dogs=new ArrayList<Dog>();  
33.         dogs.add(new Dog());  
34.         dogs.add(new Dog());  
35.         dogs.add(new Dog());  
36.         new TestDuotai().showAnimals(dogs);  
37.     }  
38. }  

 

答：不能编译通过。

问题出在该方法：showAnimals(List<Animal> animals )。该方法接受的是Animal类型的集合，按照多态的概念来说，Dog类是Animal类的子类，传入Dog类型的集合应该是没问题的，但为什么不能编译通过呢？

 

原因（反证法验证）：

 

    1）假设能够编译通过，则说明在一个需要List<Animal> 的地方可以传入ArrayList<Dog>对象，不过如果继续往方法的内部思考，就会存在问题。

    2）见showAnimals(List<Animal> animals )方法内部的注释行：//animals.add(new Cat())，假设把注释去掉，则由于Cat类也是Animal类的子类，所以该行代码也是完全没有问题的。  
    3）但回到方法的调用处：new TestDuotai().showAnimals(dogs)，我们就会发现实际上我们传入showAnimals(List<Animal> animals )方法的是Dog类型的集合，但如果在方法中执行到animals.add(new Cat())代码时，意思是要往ArrayList<Dog>中传入一个Cat类型的对象，如此一来就涉及到了泛型安全性的问题，此时就不能通过编译器的编译（集合泛型类型的检查发生在编译期，而数组类型的检查则在运行期）。

    4）结论：你不能向一个参数类型为ArrayList<Animal>的方法中传递ArrayList<Dog>类型的对象。

    5） 关于以上第4）点的补充实例，代码如下所示。

 

Java代码  

1. package com.linwei;  
2. import java.util.ArrayList;  
3. import java.util.List;  
4.   
5. abstract class Animal {  
6.     public void eat(){  
7.         System.out.println("animal eating");  
8.     }  
9. }  
10.   
11. class Dog extends Animal{  
12.     public void bark(){  
13.         System.out.println("dog barking");  
14.     }  
15. }  
16.   
17. class Cat extends Animal{  
18.     public void meow(){  
19.         System.out.println("cat meowing");  
20.     }  
21. }  
22.   
23. public class TestDuotai {  
24.     public void showAnimals(List<Animal> animals ){  
25.         for(Animal a : animals){  
26.             a.eat();  
27.         }  
28.     }  
29.       
30.     public static void main(String[] args) {  
31.           
32.         ArrayList<Dog> dogs1=new ArrayList<Animal>();  //不能编译通过  
33.           
34.         ArrayList<Animal> animals1=new ArrayList<Dog>(); //不能编译通过  
35.           
36.         List<Animal> list=new ArrayList<Animal>();  
37.           
38.         ArrayList<Dog> dogs=new ArrayList<Dog>();  
39.           
40.         ArrayList<Animal> animals = dogs; //不能编译通过  
41.           
42.         List<Dog> dogList=dogs;  
43.           
44.         ArrayList<Object> objects=new ArrayList<Object>();  
45.           
46.         List<Object> objectList=objects;  
47.           
48.         ArrayList<Object> objs=new ArrayList<Dog>(); //不能编译通过  
49.     }  
50. }