多态

多态：可以理解为事物存在的多种体现形态，比如说人：男人、女人；动物：猫，狗。
多态：

多种形态。

这里要重点讲的就是对象的多态性。

狗 x = new 狗();

动物 y = new 狗();//对象的多态性，狗对象即是狗类型，又是动物形态。

必须要明确一点：狗是动物中的一种。
意味着狗是需要继承动物的才可以这样指向。

多态性：在程序中的体现。
 就是：父类或者接口的引用指向自己的子类对象。
 

好处：提高了代码的扩展性。

弊端：前期建立父类的引用虽然可以接收后期所有该类的子类对象。
   但是只能使用父类中的功能，不能使用子类中的特有功能，
   因为前期的程序无法知道后期的子类的特有内容的。
   但是前期的程序可以使用子类覆盖了父类的方法的内容。

前提：
 1，必须存在着继承关系。
 2，通常要有覆盖操作。

 

[java] view plain copy

1. <span style="font-size:18px;">*/  
2.   
3.   
4. abstract class Animal  
5. {  
6.  abstract void eat();  
7. }  
8.   
9. class Dog extends Animal  
10. {  
11.  public void eat()  
12.  {  
13.   System.out.println("啃骨头");  
14.  }  
15.  public void lookHome()  
16.  {  
17.   System.out.println("看家");  
18.  }  
19. }  
20.   
21. class Cat extends Animal  
22. {  
23.  public void eat()  
24.  {  
25.   System.out.println("吃鱼");  
26.  }  
27.  public void catchMouse()  
28.  {  
29.   System.out.println("抓老鼠");  
30.  }  
31. }  
32.   
33.   
34. class Pig extends Animal  
35. {  
36.  public void eat()  
37.  {  
38.   System.out.println("饲料");  
39.  }  
40.  public void gongDi()  
41.  {  
42.   System.out.println("拱地");  
43.  }  
44. }  
45.   
46. class DuoTaiDemo  
47. {  
48.  public static void main(String[] args)  
49.  {  
50.   
51.     
52. </span>  

 

  
  Animal a = new Dog();//子类对象的类型提升。向上转型[类似于基本类型的类型提升,只不过这里是引用类型数据,]。
  a.eat();
  

  Dog d = (Dog)a;//向下转型。 转成子类型。  d.eat();
  d.lookHome();
  可以看出,向上转型为自动提升,向下转型必须强制

  
 }
 

[java] view plain copy

1. public static void function(Ainimal a){  
2.         a.eat();  
3.         if (a instanceof Cat){      {  
4.             Cat c=(Cat)a;  
5.             c.catchMouse();  
6.         }  
7.         else if (a instanceof Dog)  
8.         {  
9.             Dog d=(Dog)a;  
10.             d.lookHome();  
11.         }  
12.     }//<span style="color:#ff0000;">the above method showed one point should be careful in using the 多态</span>  

[java] view plain copy

1.    

 }

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

 

总的来说在多态中，成员函数在多态调用时，编译看左边，运行看右边。

                                成员变量的特点,无论编译和运行，都参考左边（引用型变量所属的类）。

 

    多态的出现在成员调用上的特点：

1，成员变量
 编译时期：参考的是引用型变量所属的类中是否有调用的成员变量，如果有，编译通过，如果没有编译失败。
 运行时期：调用的也是引用型变量所属类中的成员变量。
 
 简单说：编译和运行都看等号的左边。
 其实这种情况不多见。

2，成员函数。
 编译时期；参考的是引用型变量所属的类中是否有调用的方法。有，编译通过，没有编译失败。
 运行时期：参考的是对象所属的类中是否有调用的方法，如果有运行子类自己的方法，如果没有就父类的方法。

 简答说：编译时期看左边，运行时期看右边。
 因为函数有一个覆盖的特性。
 
 非静态方法需要和当期运行的对象进行动态绑定，哪个对象调用了这个方法，这个方法就所属于哪个对象。
 就会运行哪个对象的中的方法。

3，静态函数。
 编译时期：参考的是引用型变量所属的类中是否该方法。
 运行时期：参考的也是引用型变量所属的类中的方法。

 简单说：编译和运行都看左边。所谓的看左看右是指根据左边或右边的属性或者方法来完成调用

 因为静态方法是不所属于对象的，是所属于类的，
 它会类加载的时候，静态的绑定到所属的类上。

[java] view plain copy

1. */  
2.   
3.   
4. class Fu  
5. {  
6.  int num = 4;  
7.  public void show()// 因为覆盖的特性，  
8.  {  
9.   System.out.println("fu show run");  
10.  }  
11.  public static void staticMethod()  
12.  {  
13.   System.out.println("fu static method run");  
14.  }  
15. }  
16.   
17. class Zi extends Fu  
18. {  
19.  int num = 5;  
20.   
21.  public void show()// 因为覆盖的特性，  
22.  {  
23.   System.out.println("zi show run");  
24.  }  
25.  public static void staticMethod()  
26.  {  
27.   System.out.println("zi static method run");  
28.  }  
29. }  
30.   
31. class DuoTaiTest  
32. {  
33.  public static void main(String[] args)  
34.  {  
35.   Fu f = new Zi();  
36. //  System.out.println(f.num);//4  
37. //  f.show();//zi show run  因为函数覆盖的特性，运行的子类对象在调用show方法，  
38.        //覆盖了父类中的方法，运行的是子类自己的show方法。  
39.     
40.   f.staticMethod();  
41.   
42.   Zi z = new Zi();  
43.   z.staticMethod();  
44.   
45.   Fu.staticMethod();  
46.   Zi.staticMethod();  
47.  }  
48. }