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

时间:2023-02-11 19:31:54

面向对象

多态:

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

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.                 x.工作(); 
  51.                 子 y = (子)x; 
  52.                 y.玩(); 
  53.                 */  
  54.                 function(new Cat());
  55.                 function(new Dog());  
  56.                 function(new Pig());  
  57.   
  58.   a instanceof animal
  59.             }  
  60.             public static void function(Animal a){//Animal a = new Cat();  
  61.                 if(!(a instanceof Animal)) { 
  62.                     System.out.println("类型不匹配"); 
  63.                 } 
  64.                 else{
  65.                         a.eat();
  66.                         if(a instanceof Cat)   
  67.                                 Cat c = (Cat)a;  
  68.                                 c.catchMouse();  
  69.                         }
  70.                         else if(a instanceof Dog)  {  
  71.                                 Dog c = (Dog)a;
  72.                                 c.kanJia();
  73.                         }
  74.                        else if (ainstanceof Pig()){
  75.                                 Pig p = (Pig)a;
  76.                                 a.gongDi();
  77.                         }
  78.                 }
  79.                 //instanceof : 用于判断对象的类型。 
  80.                //对象 intanceof 类型(类类型 接口类型)   
  81.            }  
  82. }  

 多态==晚绑定

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

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

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

  比如 Parent p = new Child();

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

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

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

  (参考学习链接:http://docs.oracle.com/javase/tutorial/java/IandI/override.html)  

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

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

 

结合实例说明               

  下面举个例子(有问题的代码已注释):

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

黑马程序员——Java面向对象——多态多态示例代码

  

  例子的执行结果:

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

  

  这段代码:  

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

 

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

  

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

 

两种类型的类型转换

  (1)向上类型转换(Upcast):将子类型转换为父类型。

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

  

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

 

  (2)向下类型转换(Downcast):将父类型转换为子类型。

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

  

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

 

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

  不然也会编译出错:

 

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

 

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

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

 



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



多态注意:

成员的特点:

1,成员变量。

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

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

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

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

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

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

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

3,静态函数。

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

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

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

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

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