黑马程序员——Java面向对象——多态

面向对象

多态：

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

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 子(); 
51.                 x.工作(); 
53.                 子 y = (子)x; 
56.                 y.玩(); 
57.                 */  
58.                 function(new Cat());
59.                 function(new Dog());  
60.                 function(new Pig());  
61.   
62.   a instanceof animal
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. }  

　多态==晚绑定。

　　不要把函数重载理解为多态。

　　因为多态是一种运行期的行为，不是编译期的行为。

　　多态：父类型的引用可以指向子类型的对象。

　　比如 Parent p = new Child();

　　　　当使用多态方式调用方法时，首先检查父类中是否有该方法，如果没有，则编译错误；

　　　　如果有，再去调用子类的该同名方法。

　　（注意此处，静态static方法属于特殊情况，静态方法只能继承，不能重写Override，如果子类中定义了同名同形式的静态方法，它对父类方法只起到隐藏的作用。调用的时候用谁的引用，则调用谁的版本。）

　　（参考学习链接：http://docs.oracle.com/javase/tutorial/java/IandI/override.html）　　

　　如果想要调用子类中有而父类中没有的方法，需要进行强制类型转换，如上面的例子中，将p转换为子类Child类型的引用。

　　因为当用父类的引用指向子类的对象，用父类引用调用方法时，找不到父类中不存在的方法。这时候需要进行向下的类型转换，将父类引用转换为子类引用。     

 

结合实例说明               

　　下面举个例子（有问题的代码已注释）：

　　主要讲讲两种类型转换和两种编译时候的错误。　　

　　

　　例子的执行结果：

　　

　　这段代码：　　

 

　　Cat类中定义了eat()方法，但是Animal类中没有这个方法，a1引用是Animal类的，所以找不到，编译时出错：

　　

 

两种类型的类型转换

　　（1）向上类型转换（Upcast）：将子类型转换为父类型。

　　对于向上的类型转换，不需要显示指定，即不需要加上前面的小括号和父类类型名。

　　

 

　　（2）向下类型转换（Downcast）：将父类型转换为子类型。

　　对于向下的类型转换，必须要显式指定，即必须要使用强制类型转换。

　　

 

　　并且父类型的引用必须指向子类的对象，即指向谁才能转换成谁。

　　不然也会编译出错：

 

 

　　因为父类引用指向的是Cat类的对象，而要强制转换成Dog类，这是不可能的。

 

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

多态注意：

成员的特点：

1，成员变量。

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

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

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

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

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

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

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

3，静态函数。

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

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

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

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

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