栏目分类:
子分类:
返回
名师互学网用户登录
快速导航关闭
当前搜索
当前分类
子分类
实用工具
热门搜索
名师互学网 > IT > 软件开发 > 后端开发 > Java

夯实Java基础(四)----面向对象之多态

Java 更新时间: 发布时间: IT归档 最新发布 模块sitemap 名妆网 法律咨询 聚返吧 英语巴士网 伯小乐 网商动力

夯实Java基础(四)----面向对象之多态

 JAVA面向对象三大特性,封装、继承、多态

多态是Java面向对象最核心的内容。从一定角度来看,封装和继承几乎都是为多态而准备的。

一、多态定义 1、java多态定义:

多态就是指程序中定义的引用变量所指向的具体类型和该引用变量发出的方法调用在编译时并不确定,而是在程序运行期间才确定。一个引用变量到底会指向哪个类的实体对象,该引用变量发出的方法调用到底是哪个类中实现的方法,必须在由程序运行期间才能决定。即不修改程序代码就可以改变程序运行时所绑定的具体代码,让程序可以选择多个运行状态,这就是多态性。

Java多态也可以用一句话表示:父类的引用指向子类的对象。

2、多态的必要条件

①、继承:在多态中必须存在有继承关系的子类和父类。

②、重写:子类对父类中某点方法进行重新定义,在调用这些方法时就会调用子类的方法。

③、向上转型:在多态中需要将子类的引用赋值给父类对象,只有这样该引用才能具备技能调用父类的方法和子类的方法。

3、多态的优点

减少代码重复,使代码变得简洁。

提高代码的扩展性

4、多态的缺点

子类单独定义的方法会丢失。

多态其实是一种虚拟方法调用,在编译期间,只能调用父类中声明的方法,但在运行期间,实际执行的是子类重写父类的方法。

编译看左边,运行看右边。

二、多态的实现

不使用多态:

public class AnimalTest {
    public static void main(String[] args) {
        AnimalTest animalTest = new AnimalTest();
        animalTest.show(new Animal());
        animalTest.show(new Dog());
        animalTest.show(new Cat());
    }
    public void show(Animal animal) {
        animal.eat();
        animal.skill();
    }
    public void show(Dog dog) {
        dog.eat();
        dog.skill();
    }
    public void show(Cat cat) {
        cat.eat();
        cat.skill();
    }
}

在show()方法中的形参都传入了对象,而且重载3个相同的show()方法,如果我们有十个百个千个类需要传入方法,那么岂不是要重载上千个方法,可见这样代码的冗余非常的大,非常不利于代码的维护。

使用多态:

public class AnimalTest {
    public static void main(String[] args) {
        AnimalTest animalTest = new AnimalTest();
        animalTest.show(new Animal());
        animalTest.show(new Dog());
        animalTest.show(new Cat());
    }
    public void show(Animal animal) {
        animal.eat();
        animal.skill();
    }
}

有多态的话,只需写一个show()方法即可。

三、向上转型

子类引用的对象转换为父类类型为向上转型,就是将子类对象转为父类对象。此处父类对象也可以是接口。

public class Animal {
    public void eat() {
        System.out.println("动物吃东西");
    }
    public void skill() {
        System.out.println("动物有本领");
    }
}
class Dog extends Animal {
    public void eat() {
        System.out.println("狗吃骨头");
    }
    public void skill() {
        System.out.println("狗会看家");
    }
    //新添加的方法
    public void run() {
        System.out.println("狗跑得快");
    }
}
class Cat extends Animal {
    public void eat() {
        System.out.println("猫吃鱼");
    }
    public void skill() {
        System.out.println("猫会抓老鼠");
    }
    //新添加的方法
    public void life() {
        System.out.println("猫有九条命");
    }
}
//测试类
public class AnimalTest {
    public static void main(String[] args) {
        Animal dog = new Dog();//向上转型成Animal
        dog.eat();
        dog.skill();
        //dog.run(); Cannot resolve method 'run()'
        Animal cat = new Cat();//向上转型成Animal
        cat.eat();
        cat.skill();
        //cat.life(); Cannot resolve method 'life()'
    }
}

这时new出来的Animal引用调用的都是子类继承父类的方法,再去调用子类单独的方法就会报错,如果非要调用就需要强转。

如果在向上转型时,子类并没有重写父类的方法,那么调用的就是父类中的方法。

所以,向上转型会使子类单独定义的方法会丢失。

四、向下转型

向下转型就是把父类对象转为子类对象。因为对象的多态性只适用于方法,不适用于属性。

所以我们在使用多态时,就不能调用子类中的属性和特有的方法了,所以需要向下转型。

(内存中实际上是加载了子类所特有的属性和方法,但是由于变量声明的是父类类型,导致在编译时只能调用父类中声明的属性和方法,子类特有的属性和方法不能调用)

public class AnimalTest {
    public static void main(String[] args) {
        Animal dog = new Dog();//Dog向上转型成Animal
        Dog dog1 = (Dog) dog;//向下转型为Dog
        dog1.eat();
        dog1.skill();

        Cat cat = (Cat) dog;//java.lang.ClassCastException: com.thr.java2.Dog cannot be cast to com.thr.java2.Cat
        cat.eat();
        cat.skill();
    }
}

我们可以发现向下转型为Dog没有报错,但是转型为Cat却报错了,这个倒不难理解,因为开始向上转型本来是Dog,然后再变回Dog,总不能Dog变成Cat吧。所以会报类型转换错误。

向下转型规则:

①、向下转型的前提是父类对象指向的是子类对象(也就是说,在向下转型之前,它得向上转型)

②、向下转型只能转型为本类对象

五、Instanceof关键字

向下转型用instanceof关键字判断

a instanceof A:判断对象a是否为对象A的实例,如果是,返回true,如果不是,则返回false。

public class AnimalTest {
    public static void main(String[] args) {
        AnimalTest test = new AnimalTest();
        test.show(new Animal());
        test.show(new Dog());
        test.show(new Cat());
    }

    public void show(Animal animal) {
        if (animal instanceof Dog) {
            Dog dog = (Dog) animal;
            dog.eat();
            dog.skill();
            dog.run();
        }
    }
}

 由于show()方法只判断了Dog是否是该对象,所以Dog返回了true,输出了Dog的信息,而其他的返回了false,则没有输出然后信息。

六、总结

1、java多态一句话表示:父类的引用指向子类的对象。

2、运行时多态的前提:继承,重写,向上转型。

3、多态能够减少重复代码,使代码变得简洁,提高代码的扩展性。

4、多态其实是一种 虚拟方法调用。一句话:编译看左边,运行看右边。

5、向上转型就是将子类对象转为父类对象。

6、继承链中对象方法的调用优先级:this.show(O)、super.show(O)、this.show((super)O)、super.show((super)O)。

转载请注明:文章转载自 www.mshxw.com
本文地址:https://www.mshxw.com/it/945040.html
我们一直用心在做
关于我们 文章归档 网站地图 联系我们

版权所有 (c)2021-2022 MSHXW.COM

ICP备案号:晋ICP备2021003244-6号