Java中多态详解（参考刘意教程）

最新推荐文章于 2024-05-21 18:54:19 发布

chal_yang

最新推荐文章于 2024-05-21 18:54:19 发布

阅读量200

点赞数

本文链接：https://blog.csdn.net/weixin_42273591/article/details/99943488

版权

1.1多态概述

多态：同一个对象，在不同时刻表现出来的不同形态。使用多态，在程序中定义的引用变量到底会指向哪个类的实例对象在编程时并不确定，要在程序运行期间才能确定。

使用多态，可以不用修改源程序代码，就可以让引用变量绑定到不同的类实现上，从而使得调用的具体方法随之改变，让程序选择多个运行状态，就是多态性。

说明1：猫 Cat = new Cat(); 动物 animal = new Cat();

这里的猫在不同时刻可以是猫也可以是动物，在不同的时刻有不同的形态，就是多态。

说明2：public void eat(animal a){}

动物 animal c = new Cat(); 动物 animal d = new Dog();

这里程序中定义的引用变量不能确定到底会指向哪个类的实例对象，可能是猫，也可能是狗。

多态的前提和体现：

有继承/实现(接口实现)关系
有方法重写
有父类引用指向子类对象

1.2多态中成员访问的特点

访问成员变量：编译看左边，执行看左边
访问成员方法：编译看左边，执行看右边

访问成员变量和成员方法不一样的原因是：成员方法有重写，而成员变量没有。

访问成员变量与成员方法的具体代码如下所示：

父类Animal：

package com.inherit.test1;

public class Animal {
    int age = 15;
    String name="豆豆";

    public void eat(){
        System.out.println("动物吃东西");
    }
}

子类Cat：

package com.inherit.test1;

public class Cat extends Animal{
    int age = 10;
    String name = "点点";

    @Override
    public void eat() {
        System.out.println("猫吃鱼");
    }
}

测试demo：

package com.inherit.test1;

public class Demo {
    public static void main(String args[]){
        Animal a = new Cat();
        System.out.println(a.age);
        a.eat();
    }
}

程序运行后结果为：

15
猫吃鱼

从上述代码可以看出，在访问成员变量的时候编译看左边Animal类，执行看左边Animal类，所以最后程序运行的结果为15。而在访问成员方法的时候编译看左边的Animal类，执行看右边Cat类，故调用成员方法eat()后程序执行的结果是：猫吃鱼。

1.3多态的好处和弊端

1：多态的好处：提高了程序的可扩展性。

具体体现：定义方法的时候，使用父类类型作为参数，在使用的时候使用具体的子类参与操作。

可通过以下代码加深对程序可扩展性的理解：

animalOperator类，如果没有使用多态，则每添加一种类型的动物，就要在类中添加一个方法，具体如下所示：

package com.inherit.test1;

public class animalOperator {
    public void useAnimal(Cat c){
        c.eat();
    }
    public void useAnimal(Dog d){
        d.eat();
    }
}

父类Animal代码如下所示：

package com.inherit.test1;

public class Animal {
    int age = 15;
    String name="豆豆";

    public void eat(){
        System.out.println("动物吃东西");
    }
}

子类Cat代码如下所示：

package com.inherit.test1;

public class Cat extends Animal{
    int age = 10;
    String name = "点点";

    @Override
    public void eat() {
        System.out.println("猫吃鱼");
    }
}

子类Dog代码如下所示：

package com.inherit.test1;

public class Dog extends Animal {
    @Override
    public void eat() {
        System.out.println("狗吃骨头");
    }
}

测试demo如下所示：

package com.inherit.test1;

public class Demo {
    public static void main(String args[]){
        Cat a = new Cat();
        animalOperator ap = new animalOperator();
        ap.useAnimal(a);
    }
}

上述代码中，AnimalOperator类的可扩展性较差，当新添加一个动物的时候，需要在类中添加方法useAnimal才可以实现效果，但是如果方法useAnimal中的参数用多态的形式，添加新的动物的时候，只需在方法useAnimal中使用具体的子类就可以实现。

animalOperator类代码如下所示：

package com.inherit.test1;

public class animalOperator {
    public void useAnimal(Animal a){
        a.eat();
    }
}

测试代码demo如下所示：

package com.inherit.test1;

public class Demo {
    public static void main(String args[]){
        Animal c = new Cat();
        animalOperator ap = new animalOperator();
        ap.useAnimal(c);
        Animal d = new Dog();
        ap.useAnimal(d);
    }
}

程序运行结果如下所示：