面向对象---多态

多态，就是理解为事物存在的多种形态

Animal a=new Cat();

//1、 类型提升，向上转型（猫提升为动物了）

//2、如果想要调用猫的特有方法时，如何操作？

//3、强制将父类的引用，转成子类类型。向下转型

//　  Cat c=(Cat)a; //类似强制转换

//　  c.catchMouse();

//4、千万不要出现这样的操作，就是将父类对象转成子类类型

// 　 我们能转换的是父类应用指向了自己的子类对象时，该应用可以被提升，也可以被强制转换

//　  多态自始至终都是子类对象在做着变化

//　  Animal a=new Animal(); //动物不能转换成猫

//　  Cat c=(Cat)a;

//5、如果用猫的实例传过去，并且function里面具有猫的特性，则可以转换

//　  如果狗传过去，则不能转换

// 　 这时候，我们就需要一个判断，对实例的判断，instanceof：引用对象属于什么类型的时候用

//　  判断的时候不能把分类放在上面

 1 abstract class Animal
 2 {
 3     abstract void eat();//不确定的就用抽象，同时也要把类也要抽象
 4 }
 5 
 6 class Cat extends Animal
 7 {
 8     public void eat()
 9     {
10         System.out.println("吃鱼");
11     }
12     public void catchMouse()
13     {
14         System.out.println("抓老鼠");
15     }
16 }
17 
18 class Dog extends Animal
19 {
20     public void eat()
21     {
22         System.out.println("吃骨头");
23     }
24     public void kanjia()
25     {
26         System.out.println("看家");
27     }
28 }
29 
30 class Pig extends Animal
31 {
32     public void eat()
33     {
34         System.out.println("饲料");
35     }
36     public void gongdi()
37     {
38         System.out.println("拱地");
39     }
40 }
41 //-------------------------------------------------------
42 
43 class DuoTaiDemo2
44 {
45     public static void main(String[] args) {
46         //Animal a=new Cat();  //1、类型提升，向上转型（猫提升为动物了）
47         //a.eat();
48 
49         //2、如果想要调用猫的特有方法时，如何操作？
50         //3、强制将父类的引用，转成子类类型。向下转型
51         //Cat c=(Cat)a; //类似强制转换
52         //c.catchMouse();
53 
54         //4、千万不要出现这样的操作，就是将父类对象转成子类类型
55         //   我们能转换的是父类应用指向了自己的子类对象时，该应用可以被提升，也可以被强制转换
56         //   多态自始至终都是子类对象在做着变化
57         //Animal a=new Animal();  //动物不能转换成猫
58         //Cat c=(Cat)a;
59 
60         //5、如果用猫的实例传过去，并且function里面具有猫的特性，则可以转换
61         //  如果狗传过去，则不能转换
62         //  这时候，我们就需要一个判断，对实例的判断，instanceof：引用对象属于什么类型的时候用
63         //  判断的时候不能把分类放在上面
64 
65         function(new Cat());
66         function(new Dog());
67     }
68 
69     public static void function(Animal a)//Animal c=new Cat();   这样也提高代码的扩展性，后期不管加什么都行
70     {
71         a.eat();                //判断的时候不能把分类放在上面
72         if(a instanceof Cat){  //instanceof：引用对象属于什么类型的时候用
73             Cat c=(Cat)a;
74             c.catchMouse();
75         }
76         else if(a instanceof Dog){
77             Dog c=(Dog)a;
78             c.kanjia();
79         }
80 
81     }
82 }

View Code

在多态中成员函数的特点：

　　在编译时期：

　　　　参阅引用型变量所属的类中，是否有调用方法，如果有，编译通过，没有，编译失败

　　在运行时期：

　　　　参阅对象所属的类中是否有调用方法

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

在多态中成员变量的特点：

　　无论编译和运行，都参考左边，

在多态中静态成员函数的特点：

　　无论编译和运行，都参考左边