面向对象编程-多态

什么是多态

一类事物的多种表现形态。 人 -- 男人 女人

多态的产生

前提:有继承关系

  • 父类引用指向子类时
    Person p = new Man(); //产生多态引用
  • 父类作为参数时
    public static void show(Person p){ } //产生多态参数

多态的作用

减少了引用的声明
减少了内存的占用
减少了代码的冗余

虚拟方法调用(动态绑定)

  1. 示例

Person p = new Man(); //产生多态
p.eat();
p.walk();//实际运行的是子类Man的方法

  1. 为什么实际运行的是子类方法?
    在多态的情况下,Java 程序的运行分为两种状态
    编译时:“看左边”,看的是父类的引用。
    运行时:“看右边”,看的是子类的对象 。

引用数据类型之间的自动转换

前面我们知道基本数据类型的运算会自动作类型之间的转换,让我们可以进行运算,那引用类型数据会自动转换吗

存在继承关系的类是会自动转换的,遵守小转大自动,大转小强转

  • 向上转型:子类转父类 (小转大,系统自动完成 )
  • 向下转型:父类转子类 (大转小,需要使用强转符“(需要转换的类型)”)

强转异常

Person p = new Man(); //多态-向上转型
Man man = (Man)p; //向下转型
man.smoking(); //强转后可以调用子类中的方法
Woman woman = (Woman)p;   

以上代码在转成Woman时,编译?YES 运行?NO
为什么?
编译能过,看的左边,p和woman有继承关系。
执行时,发现p强转为man类型了,而man与woman没有继承关系的
也不是同一个类型,引发异常:ClassCastException

Java 为上述异常提供了相应的解决办法:instanceof 运算符
在实际使用中,先进行判断,再执行所写的代码,避免ClassCastException异常,使得程序中断

instanceof 运算符

  • 作用
    判断是否是同类类型
    若使用了if(a instanceof b){ 调用 } 我们就可以控制调用。避免产生ClassCastException

  • 示例

public static void show(Person p){//多态参数
            p.eat(); //动态绑定,因此可以直接调用
            p.walk();
            if(p instanceof Man){
                Man man = (Man)p;
                man.smoking();//子类持有的方法,因此需要强转
            }
            if(p instanceof Woman){
                Woman woman = (Woman)p;
                woman.shopping();//子类持有的方法,因此需要强转
            }
}

多态的应用

  • 多态的应用之一:多态数组体现

判断:数组类型是父类
作用:可以存放Person的对象,也可以存放Person子类的对象

        Person[] persons = new Person[5] ;//多态数组
        persons[0] = new Person();
        persons[1] = new Man();
        persons[2] = new Woman();
    
        for(int i = 0; i < persons.length; i++){
                                        
            persons[i].eat(); //虚拟方法调用            
            persons[i].walk();                 
        }
  • 多态的应用之二:多态参数的体现
    判断:参数列表类类型是父类
    作用:形参可传入该类型的所有子类
public class Person{
        void eat();
        void walk();
}
//当无多态时需求:展示一个男人吃饭和走路的功能
public static void show(Man man){
        man.eat(){
            //.........
        }
        man.walk(){
            //.........
        }
}
//当无多态时需求:展示一个女人吃饭和走路的功能
public static void show(Woman woman){
        woman.eat();
        woman.walk();
}
//当无多态时需求:展示一个学生吃饭和走路的功能
public static void show(Student stu){
        stu.eat();
        stu.walk();
}
//使用多态后
public static void show(Person p){//多态参数
        p.eat(); //虚拟方法调用(动态绑定)
        p.walk();
}
  • 多态的应用之三:多态的返回值体现
        public Computer getComputer(){
            return computer;    
            //若computer有子类,那么就是多态,返回其子类亦可以
        }
  • 多态的应用之四:多态的属性调用
        class Aa
        {
            int num=10;
        }
        clsaa Bb extends Aa
        {
            int num=20;
            //int num=10;
        }
        class test
        {
            
            Aa b=new Bb();//存在继承关系时,产生多态
            b.num;
        }
        
调用的结果:
        b.num 值是20,虚拟方法调用,声明的是父类引用,实际创建的是子类对象
内存原理:
        1 内存分配上,B继承了A,它拥有了A的num属性,A的属性也随着b被创建划分在new Bb()的堆内存中
        2 java的就近原则:编译时jvm会根据创建的对象去选择就近的属性
最后编辑于
©著作权归作者所有,转载或内容合作请联系作者
平台声明:文章内容(如有图片或视频亦包括在内)由作者上传并发布,文章内容仅代表作者本人观点,简书系信息发布平台,仅提供信息存储服务。