多态的详细介绍

多态：
   定义：某一类事物的多种存在形态
列：动物中 猫 狗；
    猫这这个对象对应的类型是猫类型；
          猫 a = new 猫()；
    同时猫也是动物中的一种，也可以把猫称为动物；
        动物 b = new 猫();
    动物是猫和狗具体事物中抽取出来的父类型
       父类型引用指向子类型对象。

对象的多态性：
    class 动物{
    class 猫 extends 动物{}
    class 狗 extends 动物{}
        猫 a = new 猫();
        动物  b = new 猫();//一个对象两种形态
    猫这类事物即具备猫的形态又具备动物的形态，也就算对象的多态性；
    简单的说：就是一个对象对应着不同的类型；
    
多态在代码中的体现：
    父类或者接口的引用指向其子类对象
    
多态的好处：
    提高了代码的扩展性，前期定义的代码可以使用后期定义的内容；


    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 DuoTaiDemo{

    public static void main(String[] args){
            
        Cat c = new Cat();
        Dog d = new Dog();
        Animal a = new Dog();
                method1(a);
        method1(c);
        method1(d);

    }

    public static viod method1(Animal a){
        a.eat();
        a.catchMouse();//编译报错，动物里没有抓老鼠的方法。
        
    }

}
《多态的弊端：
        前期定义的内容不能调用后期子类中特有的内容。
  多态的前提：
        1：必须有关系 ：继承 实现 。
        2：要有覆盖。
》

    if(a instanceof Cat){
    Cat c = (Cat)a;
    c.catchMouse();
/*
java 中的instanceof 运算符是用来在运行时指出对象是否是特定类的一个实例。instanceof通过返回一

个布尔值来指出，这个对象是否是这个特定类或者是它的子类的一个实例。
用于判断对象的具体类型，只能用于引用数据类型判断，通常在向下转型前用于健壮性判断；
*/    

}

    Animal a = new Cat();//自动类型提升猫对象，提升了动物类型，但是特有的功能无法访问
                 //作用就是限制了对特有功能的访问；
                 //专业上讲：向上转型将子类型隐藏，就不使用子类的特有方法；
                 //如果还想使用具体动物猫的特有功能，可以将该对象进行向下转型；
                 //向下转型的目的是为了使用子类中的特有方法。
    a.eat();
    Cat c = (Cat)a;
    c.eat();
    c.catchMouse();


/*注意：对于转型，自始至终都是子类对象在做着类型的变化(如小猫转动物，小猫转小猫)

Animal an = new Dog();
Cat c = (Cat)an;
错误：报classCatException 类型转换异常

*/


class 毕姥爷{
         viod 讲课(){
    System.out.println("管理课")；

    }
              viod 钓鱼(){
    System.out.println("钓鱼")；

    }
}

class 毕老师 extends 毕姥爷{
         viod 讲课(){
    System.out.println("java")；

    }
              viod 看电影(){
    System.out.println("无间道")；

    }
}

class DuoTaiDemo{

public static void main(String[] args){
    //毕老师 b = new 毕老师();
    //   b.讲课();
    //   b.看电影();

    毕姥爷 bl = new 毕老师();
         bl.讲课();   -----------System.out.println("java")；
         bl.钓鱼();   -----------System.out.println("钓鱼")；
    //   bl.看电影();  错误

    }
}


多态时 成员的特点：

1，成团变量：
    
    编译时参考引用型变量所属的类中是否有调用的变量，有，编译通过；没有，编译失败；
    运行时参考引用型变量所属的类中是否有调用的变量，并运行该属性类中的成员变量；
    简单说：编译和运行都参考等号的左边。
2，成员函数：
    
    编译时参考引用型变量所属的类中是否有调用的函数，有，编译通过；没有，编译失败；
    运行时参考的是对象所属的类中是否有调用的函数；
    简单说：编译看左边，运行看右边。
3，静态函数：
    
    编译时参考引用型变量所属的类中是否有调用的静态方法；
    运行时参考引用型变量所属的类中是否有调用的静态方法；
    简单说：编译和运行都看左边。
        <!--静态方法是不需要对象的，直接类名调用即可-->

---------------------------------------
成员变量：
class Fu{

    int num = 3;
}
class Zi extends Fu{

    int num = 4;
}
class DuoTaiDemo{

public static void main(String[] args){    
    
    Fu f = new Zi();
    System.out.println(f.num)；//运行结果等于3  编译和运行都看左边
    }
}
------------------------------------------
成员函数：
class Fu{
    
    void Show(){
   System.out.println("fu show")；
    
    }
}

class Zi extends Fu{
    
    void Show(){
   System.out.println("zi show")；
    
    }
}

public static void main(String[] args){    
    
    Fu f = new Zi();
    f.show()；//运行结果等于"zi show"  编译看左边和运行看右边
    }
}