多态

面向对象

多态：

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

1，多态的体现

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

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

2，多态的前提
必须是类与类之间有关系。要么继承，要么实现。

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

3，多态的好处

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

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

5，多态的应用

abstractclass Animal { 
        public abstractvoid eat(); 
} 
class Cat extends Animal  {   
        public void eat(){   
                System.out.println("吃鱼");   
        }   
        public void catchMouse()  {   
                System.out.println("抓老鼠");   
        }   
}   
class Dog extends Animal  {   
        public void eat()  {   
                System.out.println("吃骨头");   
        }   
        public void kanJia()  {   
                System.out.println("看家");   
        }   
}   
class Pig extends Animal  {   
        public void eat()  {   
                System.out.println("饲料");   
        }   
        public void gongDi()  {   
                System.out.println("拱地");   
        }   
}   

class DuoTaiTest   {   
        public static void main(String[] args)   {   
                Animal a = new Cat(); 
                //类型提升。 向上转型。 父类类型指向子类对象  
                a.eat();  //吃鱼 

                //如果想要调用猫的特有方法时，如何操作？   
                //强制将父类的引用。转成子类类型。向下转型。   
                Cat c = (Cat)a;   
                c.catchMouse(); //抓老鼠 

                //不要出现这样的操作，就是将父类对象转成子类类型。   
                //我们能转换的是父类应用指向了自己的子类对象时。 
                //该应用可以被提升，也可以被强制转换。   
                //多态自始至终都是子类对象在做着变化。   
                //      Animal a = new Animal();   
                //      Cat c = (Cat)a;   


                /*  
                父 x = new 子();  

                x.工作();  

                子 y = (子)x;  


                y.玩();  
                */   
                function(new Cat()); 
                function(new Dog());   
                function(new Pig());   


            }   
            public static void function(Animal a){//Animal a = new Cat();   
                if(!(a instanceof Animal)) {  
                    System.out.println("类型不匹配");  
                }  
                else{ 
                        a.eat(); 
                        if(a instanceof Cat)  {   
                                Cat c = (Cat)a;   
                                c.catchMouse();   
                        } 
                        else if(a instanceof Dog)  {   
                                Dog c = (Dog)a; 
                                c.kanJia(); 
                        } 
                       else if (ainstanceof Pig()){ 
                                Pig p = (Pig)a; 
                                a.gongDi(); 
                        } 
                } 
                //instanceof : 用于判断对象的类型。  
               //对象 intanceof 类型(类类型 接口类型)    
           }   
}   

多态注意：

成员的特点：

1，成员变量。

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

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

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

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

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

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

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

3，静态函数。

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

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

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

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

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

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