Java基础--多态

凌风博客原创作品。转载请注明出处http://blog.csdn.net/q549130180/article/details/45198201

多态：可以理解为事物的多种形态

例如：
人:男人，女人
动物：猫，狗
动物 x= new 猫();


1、多态的体现
父类的引用指向了自己的子类对象
父类的引用也可以接收自己子类的对象
2、多态的前提
必须是类与类之间有关系，要么继承，要么实现
通常还有一个前提：存在覆盖
3、多态的好处
多态的出现很大的提高了程序的扩展性
4、多态的弊端
提高了扩展性，但是只能使用父类的引用访问父类中的成员
5、多态的应用


6、多态的出现代码中的特点（多态使用的注意事项）
示例：
动物
猫，狗

[java]  view plain copy

1. abstract class Animal  
2. {  
3.     public abstract void eat();  
4. }  
5.   
6. class cat extends Animal  
7. {  
8.     public void eat(){  
9.         System.out.print("吃鱼");  
10.     }  
11.     public void catchMouse(){  
12.         System.out.print("抓老鼠");  
13.     }  
14. }  
15.   
16. class Dog extends Animal  
17. {  
18.     public void eat(){  
19.         System.out.print("吃骨头");  
20.     }  
21.     public void kanjia(){     
22.         System.out.print("看家");  
23.       
24.     }  
25. }  
26.   
27. class Pig extends Animal  
28. {  
29.     public void eat(){  
30.         System.out.print("饲料");  
31.     }  
32.     public void GongDi(){  
33.         System.out.print("拱地");  
34.     }  
35.   
36. }  

[java]  view plain copy

1. class DuoTaiDemo  
2. {  
3.     public static void main(String[] args)   
4.     {  
5.           
6.         Cat c = new Cat();    //类型提升，向上转型    
7.         c.eat();  
8.   
9.         //如果想要调用猫的特有方法时，如何操作？  
10.         //强制将父类的引用，转成子类类型,向下转型  
11.   
12.         Cat c = (Cat)a;  
13.         c.catchMouse();  
14.   
15.         //千万不要出现这样的操作，就是将父类对象转成子类类型。  
16.         //我们能转换的是父类应用指向了自己的子类对象时，该应用可以被提升，也可以被强制转换。  
17.         //多态自始至终都是子类对象在做着变化  
18.         //Animal a = new Animal();  
19.         //Cat c = (Cat)a;  
20.   
21.       
22.   
23.     }  
24.     public static void function(Animal a){  //Animal c = new Cat();  
25.         a.eat();  
26.           
27.   
28.     }  
29.   
30. }  

示例2

[java]  view plain copy

1. class Fu  
2. {  
3.     void method1(){  
4.         System.out.println("fu method_1");  
5.     }  
6.     void method2(){  
7.         System.out.println("fu method_2");  
8.     }  
9. }  
10. class Zi extends Fu  
11. {  
12.     void method1(){  
13.         System.out.println("zi method_1");  
14.     }  
15.     void method3(){  
16.         System.out.println("zi method_3");  
17.     }  
18. }  
19.   
20. class    
21. {  
22.     public static void main(String[] args)   
23.     {  
24.         Fu f = new Zi();  
25.         f.method1();   
26.         f.method2();   
27.         //f.method3();   
28.       
29.     }  
30. }  

总结

在多态中成员函数的特点：
在编译时期:参阅引用类型变量所属的类中是否有调用的方法。如果有，编译通过，如果没有编译失败
在运行时期:参阅对象所属的类中是否有调用的方法。


简单总结就是:成员函数在多态调用时，编译看左边，运行看右边


**在多态中，成员变量的特点
**无论编译还是运行，都参考左边（引用型变量所属的类）


**在多态中，静态成员函数的特点：
**无论编译和运行，都参考左边。