黑马程序员面向对象-----多态

---------------------- ASP.Net+Unity开发、.Net培训、期待与您交流！ ----------------------

面向对象

多态：

多态的概述：某一类事物的多种存在的多种形态。

1，多态的体现

父类的引用指向了自己的子类对象。

父类的引用也可以接收自己的子类对象。

2，多态的前提

必须是类与类之间有关系。要么继承，要么实现。

通常还有一个前提：存在覆盖。

3，多态的好处

多态的出现大大的提高程序的扩展性。

4，多态的弊端

提高了扩展性，但是只能使用父类的引用访问父类中的成员。

5，多态的应用

1. abstractclass Animal {
2.         public abstractvoid eat();
3. }
4. class Cat extends Animal  {  
5.         public void eat(){  
6.                 System.out.println("吃鱼");  
7. }  
8. public void catchMouse()  {  
9.                 System.out.println("抓老鼠");  
10.         }  
11. }  
12. class Dog extends Animal  {  
13.         public void eat()  {  
14.                 System.out.println("吃骨头");  
15.         }  
16.         public void kanJia()  {  
17.                 System.out.println("看家");  
18.         }  
19. }  
20. class Pig extends Animal  {  
21.         public void eat()  {  
22.                 System.out.println("饲料");  
23.         }  
24.        public void gongDi()  {  
25.                 System.out.println("拱地");  
26.         }  
27. }  
28.   
29. class DuoTaiTest   {  
30.         public static void main(String[] args)   {  
31.                 Animal a = new Cat();
32.                 //类型提升。 向上转型。 父类类型指向子类对象 
33.                 a.eat();  //吃鱼
34.   
35.                 //如果想要调用猫的特有方法时，如何操作？  
36.                 //强制将父类的引用。转成子类类型。向下转型。  
37.                 Cat c = (Cat)a;  
38.                 c.catchMouse(); //抓老鼠
39.   
40.                 //不要出现这样的操作，就是将父类对象转成子类类型。  
41.                 //我们能转换的是父类应用指向了自己的子类对象时。
42.                 //该应用可以被提升，也可以被强制转换。  
43.                 //多态自始至终都是子类对象在做着变化。  
44.                 //      Animal a = new Animal();  
45.                 //      Cat c = (Cat)a;  
46.                   
47.   
48.                 /* 
49.                 父 x = new 子(); 
50.  
51.                 x.工作(); 
52.  
53.                 子 y = (子)x; 
54.  
55.  
56.                 y.玩(); 
57.                 */  
58.                 function(new Cat());
59.                 function(new Dog());  
60.                 function(new Pig());  
61.   
62.   
63.             }  
64.             public static void function(Animal a){//Animal a = new Cat();  
65.                 if(!(a instanceof Animal)) { 
66.                     System.out.println("类型不匹配"); 
67.                 } 
68.                 else{
69.                         a.eat();
70.                         if(a instanceof Cat)  {  
71.                                 Cat c = (Cat)a;  
72.                                 c.catchMouse();  
73.                         }
74.                         else if(a instanceof Dog)  {  
75.                                 Dog c = (Dog)a;
76.                                 c.kanJia();
77.                         }
78.                         else if (ainstanceof Pig()){
79.                                 Pig p = (Pig)a;
80.                                 a.gongDi();
81.                         }
82.                 }
83.                 //instanceof : 用于判断对象的类型。 
84.                //对象 intanceof 类型(类类型 接口类型)   
85.            }  
86. }  

多态注意：

成员的特点：

1，成员变量。

编译时：参考引用型变量所属的类中的是否有调用的成员变量，有，编译通过，没有，编译失败。

运行时：参考引用型变量所属的类中的是否有调用的成员变量，并运行该所属类中的成员变量。

简单总结：编译和运行都参考等号的左边。哦了。

2，成员函数(非静态)。

编译时：参考引用型变量所属的类中的是否有调用的函数。有，编译通过，没有，编译失败。

运行时：参考的是对象所属的类中是否有调用的函数。

简单总结：编译看左边，运行看右边。因为成员函数存在覆盖特性。 

3，静态函数。

编译时：参考引用型变量所属的类中的是否有调用的静态方法。

运行时：参考引用型变量所属的类中的是否有调用的静态方法。

其实对于静态方法，是不需要对象的。直接用类名调用即可。

简单总结：编译和运行都看左边。

总结：非静态成员函数，编译时看左边，运行时看右边。其他都看左边。

多态总结：其实我们生活中有很多地方也是用到多态的，比如生活的角色扮演，是儿子的话，看到爸爸应该叫爸爸，是学生看到老师，应该叫老师，我们在身份时时刻刻在进行不断的变化，这就是多态。

---------------------- ASP.Net+Unity开发、.Net培训、期待与您交流！ ----------------------