黑马程序员_Java面对对象——多态

------- android培训、java培训、期待与您交流！ ----------

一、 什么是多态？

多态的概念：

           多态是指一类事物的多种存在形态。

1.        多态的体现

         父类的引用指向了自己的子类对象。

         父类的引用也可以接收自己的子类对象。

2.        多态的前提

         必须是类与类之间有关系。要么继承，要么实现。

         通常还有一个前提：存在覆盖。

3.        多态的好处

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

4.        多态的弊端：

                   提高了扩展性，但是只能使用父类的引用访问父类中的成员。

5.        多态的应用

abstract class Animal
{
    //所有动物都有吃的行为
    abstract void eat();

}

class Cat extends Animal
{
    public void eat()
    {
        System.out.println("吃鱼");
    }
    //猫的特有行为
    public void catchMouse()
    {
        System.out.println("抓老鼠");
    }
}


class Dog extends Animal
{
    public void eat()
    {
        System.out.println("吃骨头");
    }
    //狗的特有行为
    public void kanJia()
    {
        System.out.println("看家");
    }
}


class Pig extends Animal
{
    public void eat()
    {
        System.out.println("饲料");
    }
    //猪的特有行为
    public void gongDi()
    {
        System.out.println("拱地");
    }
}
class DuoTaiDemo 
{
    public static void main(String[] args) 
    {
        //Cat c = new Cat();
        //c.eat();

        //Dog d = new Dog();
        //d.eat();
        //Cat c = new Cat();
        /*
        Cat c1 = new Cat();
        function(c1);

        function(new Dog());
        function(new Pig());
        */

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

        
        function(new Cat());
        function(new Dog());
        function(new Pig());
        

        
    }
    //
    public static void function(Animal a)//Animal a = new Cat();
    {
        a.eat();
        //a.catchMouse();
    }
    /*
    public static void function(Cat c)//
    {
        c.eat();
    }
    public static void function(Dog d)
    {
        d.eat();
    }

    public static void function(Pig p)
    {
        p.eat();
    }
    */

}

二、 多态的注意事项：

成员的特点：

1.     成员变量。

编译时：参考引用型变量所属的类中的是否有调用的成员变量，有，编译通过，没有，编译失败。

运行时：参考引用型变量所属的类中的是否有调用的成员变量，并运行该所属类中的成员变量。

总结成一句话：编译和运行都看等号的左边，引用指向哪个就用哪个。

2.     成员函数(非静态)。

编译时：参考引用型变量所属的类中的是否有调用的函数。有，编译通过，没有，编译失败。

运行时：参考的是对象所属的类中是否有调用的函数。

总结成一句话：编译看左边，运行看右边。因为成员函数存在覆盖特性。 

3.     静态函数。

编译时：参考引用型变量所属的类中的是否有调用的静态方法。

运行时：参考引用型变量所属的类中的是否有调用的静态方法。

其实对于静态方法，是不需要对象的。直接用类名调用即可。

总之就是编译和运行都看左边。

总结成一句话：非静态成员函数，编译时看左边，运行时看右边；其他都看左边。

多态的总结;

       在实际生活着实际处处存在这多态现象，如果把我们看作是一个对象的话，我们在家表现为孩子的形态，学校是学生的形态等等，主要还是看我们的父类有什么，总之就是我们会随着继承的父类变化而变化。

------- android培训、java培训、期待与您交流！ ----------