JAVA 学习模块十四： 多态

1.多态使用

/*
对象的多态性：
猫这类事物既具备猫的形态又具备动物的形态，这就是对象的多态性。
简单说就是一个对象对应着不同类型。
多态在代码中的体现：
    父类或者接口的引用指向其子类的对象。


*/

abstract class Ani
{
    abstract void eat();

}

class  Cat extends Ani

{
    void eat()
    {
        System.out.println("chi");
    }
    void catmo()
    {
        System.out.println("zhua");
    }

}

class Dog extends Ani
{
    void eat()
    {
        System.out.println("ke");

    }
    void lookhome()
    {
        System.out.println("kan");
    }

}

class DuoTaiDemo
{
    public static void main(String[] args)
    {
        Cat c  = new Cat();
        Dog d = new Dog();
        method(c);
        method(d);


    }

    public static void method(Cat c)
    {
        c.eat();
    }

    public static void method(Dog d)
    {
        d.eat();
    }


}

/*
对象的多态性：
猫这类事物既具备猫的形态又具备动物的形态，这就是对象的多态性。
简单说就是一个对象对应着不同类型。
多态在代码中的体现：
    父类或者接口的引用指向其子类的对象。


*/

abstract class Ani
{
    abstract void eat();

}

class  Cat extends Ani

{
    void eat()
    {
        System.out.println("chi");
    }
    void catmo()
    {
        System.out.println("zhua");
    }

}

class Dog extends Ani
{
    void eat()
    {
        System.out.println("ke");

    }
    void lookhome()
    {
        System.out.println("kan");
    }

}

class DuoTaiDemo
{
    public static void main(String[] args)
    {
        Cat c  = new Cat();
        Dog d = new Dog();
        method(c);
        method(d);
        method(new Cat());


    }

    public static void method(Cat c)
    {
        c.eat();
    }

    public static void method(Dog d)
    {
        d.eat();
    }
    public static void method(Ani a)
{
    a.eat();
}

}

2.多态的好处与弊端

好处：提高了代码的扩展性，前期定义的代码可以使用后期的内容。
弊端：前期定义的内容不能使用（调用）后期子类的特有内容。
多态的前提：
1.必须有关系，继承，实现。
2.要有覆盖。

3.转型

4.多态的特点

/*
多态的特点：
1.成员变量
    编译时： 参考引用类型变量所属类中是否有调用的成员变量，有，编译通过，没有，编译失败
    运行时： 参考引用类型变量所属类中是否有调用的成员变量
    简单说： 编译和运行都参考等号左边。

*/




class Fu
{
    int num = 3;
}

class Zi

{
    int num = 4;

}

class DuoTai
{
    public static void main(String[] args) 
    {
        Zi z = new Zi();
        System.out.println(z.num);// 输出是4


        Fu z = new Zi();
        System.out.println(z.num);// 输出是3
    }

}

/*
多态的特点：
1.成员变量
    编译时： 参考引用类型变量所属类中是否有调用的成员变量，有，编译通过，没有，编译失败
    运行时： 参考引用类型变量所属类中是否有调用的成员变量
    简单说： 编译和运行都参考等号左边。

2.成员函数

    编译时： 参考引用型变量所属的类中是否有调用的函数，有，编译通过，没有，编译失败。
    运行时： 参考的是对象所属的类中是否有调用的函数
    简单说： 编译看左边，运行看右边

3.静态函数。
    编译和运行都看左边。
    其实对于静态方法，是不需要对象的，直接类名调用即可。


*/




class Fu
{
    int num = 3;
    void show()
    {
        System.out.println("Fu show");
    }
}

class Zi

{
    int num = 4;
    void show()
    {
        System.out.println("Zi show");
    }

}

class DuoTai
{
    public static void main(String[] args) 
    {
        //Zi z = new Zi();
        //System.out.println(z.num);// 输出是4


        //Fu z = new Zi();
        //System.out.println(z.num);// 输出是3
        Fu f = new Zi();
        f.show();
    }

}