面向对象编程-多态

什么是多态

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

多态的产生

前提：有继承关系

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

多态的作用

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

虚拟方法调用（动态绑定）

示例

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

为什么实际运行的是子类方法？
在多态的情况下，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会根据创建的对象去选择就近的属性