Java 多态

/*对象的多态
父类类型的对象指向了子类对象
猫这类事物既具有猫的形态也具有动物的形态
就是一个对象对应多个不同的类型
多态的好处：
前期定义的代码可以使用后期的内容
多态的局限性：
前期定义的内容不能调用后期子类出现的特有内容
多态的前提：
1.必须有关系，实现，继承
2.要有覆盖
*/

abstract class Animal
{
    abstract void eat();
}

 class mao extends Animal 
 {
     void eat()
     {
         System.out.println("鱼");
     }
     void catchmouse()
     {
          System.out.println("miao");
     }
 }
 
 class gou extends Animal 
 {
     void eat()
     {
         System.out.println("骨头");
     }
 }
 
 class zhu extends Animal
 {
     void eat()
     {
         System.out.println("饲料");
     }
 }
 
 class duotai
 {
     public static void main(String[] args)
     {
        mao x=new mao();
        gou y=new gou();//一个对象，两种形态
        method(x);
        method(y);
        
        
        Animal a= new mao(); //自动类型提升，猫提升为动物类型
                             //就不能访问猫的特有功能了
                             //作用就是可以限制对特有功能的访问
                             //专业讲叫做向上转型
                             //如果还想用具体动物猫的功能，可以将特有类型向下转型
        mao b= (mao)a;
        //向下转型：是为了使用子类中的特有功能
                             
        a.eat();  
        a.catchmouse();  //不能够运行
        
        gou c=(gou)a;//ClassCastException
        //对于转型，自始自终都是子类在做着类型的变化
        
        
        
        
     }
     
     public static void method(Animal c)
     {
         c.eat();
         //instanceof 用于判断具体数据类型，只能够运用于引用数据类型
         if(c instanceof mao)
         {
             mao d=(mao) c;
             d.catchmouse();
         }
     }
 }
 
 
 /*多态的特点
 1.成员变量 根据类型判定
 编译时参考引用型变量所属的类中是否有调用的成员变量，有编译通过，无编译失败
 运行时参考引用变量所属的类中是否有调用的成员变量
 编译和运行都看左边；
 
 2.成员函数（非静态）,根据对象决定
 编译时参考引用型变量所属的类中是否有调用的成员变量，有编译通过，无编译失败
 运行时参考所指向对象的类中是否有调用的函数
 成员函数在编译时看左边，运行时看右边

 3.静态函数 根据类型判定
 编译时参考引用型变量所属的类中是否有调用的成员变量，有编译通过，无编译失败
 运行时参考引用变量所属的类中是否有调用的成员变量
 编译和运行都看左边；
 
 */
 class Fu
 {
    int num=3;
    static void method()
    {
        System.out.println(fu static)
    }
    void show()
    {
        System.out.println(fu)
    }
 }
 class Zi extends Fu
 {
    int num=4; 
    void show()
    {
        System.out.println(zi)
    }
    static void method()
    {
        System.out.println(zi static)
    }
 }
 
 class duotai
 {
    Fu f=new Zi();
    System.out.println(f.num);     //3  覆盖只发生在成员函数
    f.show();     //zi
    f.method();  //fu static
 }
 
 class Fu
 {
    
 }
 class Zi extends Fu
 {
    int num=4; 
 }
 
 class duotai
 {
    Fu f=new Zi();
    System.out.println(f.num);   //报错，f类没num成员
     
 }