面向对象_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); 
    } 
}