面向对象_03_多态

**何为多态呢？简单点：为了让程序简单，扩展性更强，over~

   多态：可以理解为事物的多种体现形式。

  比如：

动物：猫，狗

猫   x=new 猫();动物 x=new 猫();（多态的体现，一个对象有2种以上的形态）

  那人也如此：

人：男人，女人

男人 x=new 男人();

人   x=new 男人();（一样的，你既是男人也是人吧，多态~）

1.多态的体现

  父类的引用指向了自己的子类对象，父类的引用也可以接受自己的子类对象

2.多态的前提

  1、必须是类与类之间有关系，要么继承，要么实现。2、通常还有个前提，存在覆盖

3.多态的优势

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

4.多态的弊端

  只能使用父类的引用访问父类中的成员

5.多态的应用

6.多态在代码中的特点（多态使用的注意事项）

下面有一例子可以说明多态的感觉：

abstract  class  Animal {     abstract  void  eat(); // 定义父类的抽象方法

} 

class  Dog extends  Animal {     void  eat()     { 

        System.out.println("啃骨头");     }     void  lookHome()     { 

        System.out.println("看家");     } } 

class  Cat extends  Animal {     void  eat()     { 

        System.out.println("吃鱼");     }     void  catchMouse()     { 

        System.out.println("抓老鼠");     } } 

class  Pig extends  Animal {     void  eat()     { 

        System.out.println("饲料");     }     void  gongDi()     { 

        System.out.println("拱地"); 

  } } 

class  DuoTaiDemo {     public  static void  main(String[] args)     { 

//     Cat c = new Cat(); //     c.eat(); //     c.catchMouse(); 

       Animal a = new   Cat(); //自动类型提升，猫对象提升了动物类型。但是特有功能无法s访问。                           //作用就是限制对特有功能的访问。                           //专业讲：向上转型。将子类型隐藏。就不用使用子类的特有方法。 

//     a.eat(); 

        //如果还想用具体动物猫的特有功能。         //你可以将该对象进行向下转型。 //     Cat c = (Cat)a;//向下转型的目的是为了使用子类中的特有方法。 //     c.eat(); //     c.catchMouse(); 

/*      注意：千万不要出现一种操作，就是将父类对象转成子类类型。比如：        Animal a=new Animal();        cat c=(Cat)a;    像这样就挂了，动物不能被强制为猫       所以，我们能转换的是父类引用指向了自己的子类对象时，该引用可以被提升，也可以被强制转换

*/

//     注意：对于转型，自始自终都是子类对象在做着类型的变化。 //     Animal a1 = new Dog(); //     Cat c1 = (Cat)a1;//ClassCastException（这个错误的意思就是，这狗不能转换成猫，要不就逆天了）        /*        Cat c = new Cat(); 

//     Dog d = new Dog(); 

//     c.eat();        method(c); //     method(d); //     method(new Pig());         */ 

       method(new   Dog()); 

    } 

    public  static void  method(Animal a)//这就相当于这个，Animal a = new Dog();     {        a.eat(); 

 if (a instanceof Cat)//instanceof：用于判断对象的具体类型。只能用于引用数据类型判断                      //通常在向下转型前用于健壮性的判断。 

       {           Cat c = (Cat)a;           c.catchMouse();        }        else if (a instanceof Dog)        {           Dog d = (Dog)a;           d.lookHome();        }        else        { 

       } 

    }     /*    public static void method(Cat c)     {        c.eat();     }    public static void method(Dog d)     { 

    }     */ } 

多态时，成员变量，静态函数，成员函数的变化：

1，成员变量。    编译时：参考引用型变量所属的类中的是否有调用的成员变量，有，编译通过，没有，编译失败。    运行时：参考引用型变量所属的类中的是否有调用的成员变量，并运行该所属类中的成员变量。    简单说：编译和运行都参考等号的左边。哦了。    作为了解。 

2，成员函数(非静态)。    编译时：参考引用型变量所属的类中的是否有调用的函数。有，编译通过，没有，编译失败。    运行时：参考的是对象所属的类中是否有调用的函数。    简单说：编译看左边，运行看右边。     因为成员函数存在覆盖特性。 

3，静态函数。         编译时：参考引用型变量所属的类中的是否有调用的静态方法。         运行时：参考引用型变量所属的类中的是否有调用的静态方法。         简单说，编译和运行都看左边。         其实对于静态方法，是不需要对象的。直接用类名调用即可。 */ 
class  Fu { // int num = 3;     void  show()     {         System.out.println("fu show");     } 
    static  void method()     {         System.out.println("fu static method");     } } 
class  Zi extends  Fu { // int num = 4;     void  show()     {         System.out.println("zi show");     } 
    static  void method()     {         System.out.println("zi static method");     } } 
class   DuoTaiDemo3 {     public  static  void main(String[] args)     {         Fu.method();         Zi.method();         Fu f = new  Zi();// //      f.method(); //      f.show(); //      System.out.println(f.num); 
//      Zi z = new Zi();

//     System.out.println(z.num);     } }