Java面向对象特征之三：多态

一：面向对象三大特征之三：多态

1.多态是什么？

同类型的对象，执行同一个行为，会表现出不同的行为特征。

比如：猫和狗都是动物类型，执行同一个行为，但是会表现出不同的行为特征；

2.多态的常见形式

父类类型 对象名称 = new 子类构造器;
接口 对象名称 = new 实现类构造器;

例：

/*
动物类父类抽象类
 */
public abstract class Animal {
    public abstract void run();
}

/*
狗类：子类，继承动物类
 */
public class Dog extends Animal {
    @Override
    public void run() {
        System.out.println("狗恰狗粮");
    }
}

/*
猫类：子类，继续动物类
 */
public class Cat extends Animal {
    @Override
    public void run() {
        System.out.println("猫恰猫粮");
    }
}

public class PolymorphismTest {
    public static void main(String[] args) {
        //这是之前的形式
        Dog d1 = new Dog();
        d1.run();

        Cat c1 = new Cat();
        c1.run();
        System.out.println("----------------");

        /*
        多态的形式为：父类类型 对象名称 = new 子类构造器;
        例如下 右边的狗对象 赋值 给 左边的动物对象
        下方狗对象只代表单种动物类型；但是动物对象代表所有的动物，属于是小范围赋值给大范围，合情合理。
         */
        Animal d2 = new Dog();
        d2.run();

        Animal c2 = new Cat();
        c2.run();
    }
}

控制台输出结果：

---

3.多态中成员访问特点

方法调用：编译看左边，运行看右边；

 

如上：

1.编译阶段的时候会去到这个Animal类里找run方法 

2.找到了以后，等到运行的时候就会去Dog类里找run方法

---

变量调用：编译看左边，运行也看左边；（多态侧重行为多态）

  

 

---

4.多态的前提

需要有继承/实现关系；有父类引用指向子类对象；有方法重写。

---

二：多态的优势

1.优势

（1）在多态形式下，右边对象可以实现解耦合，便于扩展和维护；

没换掉之前：

 

 把🐕对象更换成🐱，run行为也会跟着改变，不需要改动代码

---

 （2）定义方法的时候，使用父类作为参数，该方法就可以接收这个父类的一切子类对象，体现出多态的扩展与便利；

所有动物参加赛跑比赛

public class PolymorphismTest {
    public static void main(String[] args) {
        System.out.println("---比赛开始---");
        Animal d1 = new Dog();
        go(d1);
        
        Animal c1 = new Cat();
        go(c1);
        System.out.println("吃得一样快，比赛结束，平手平手");
        
    }
    /*需求：所有动物可以一起参加比赛
     */
    public static void go(Animal a){
        a.run();
    }
}

执行原理：在上列代码中，第一步会先将狗对象的地址给到a1，然后go方法再将狗对象的地址传给形参a，形参a接收到对象地址后，根据地址去访问狗对象里的run行为。

---

2.多态下产生的问题

多态下不能使用子类的独有功能：

因为父类是被继承的，因此继承了父类的子类会有父类的一切行为，但是父类是没有子类独有行为的。

 

三：多态下引用类型的类型转换

1.引用类型是什么？

也就是我们自己定义的：动物类、学生类、狗类猫类等等。

2.引用类型的类型转换

自动类型转换：子类对象赋值给父类类型的变量指向。

因为父类范围大，所有子类对象赋值给父类类型的变量指向➡属于：小范围赋值给大范围，因此是自动类型转换。

强制类型转换（从父到子）：

子类 对象变量 = (子类)父类类型的变量;

作用：可以解决多态下的劣势，可以实现调用子类的独有行为（方法功能）。

public class Animal {
    /*
    动物通用行为：跑
     */
    public void run(){
        System.out.println("动物可以跑^_^");
    }
}

public class Dog extends Animal{
    /*
    重写父类run方法
     */
    @Override
    public void run() {
        System.out.println("🐕跑得飞快~~");
    }
    /*
    狗类独有方法：看门
     */
    public void lookDoor(){
        System.out.println("🐕看门");
    }
}

public class Cat extends Animal{
    @Override
    public void run() {
        System.out.println("🐱跑得也很快");
    }
    public void bullyDog(){
        System.out.println("🐱在欺负🐕");
    }
}

public class PolymorphismTest {
    public static void main(String[] args) {
        System.out.println("多态下引用类型的自动类型转换：");
        Animal a1 = new Dog();
        a1.run();
//        报错，多态下不能访问子类独有功能
//        a1.lookDoor();
        System.out.println("------------");
        Animal a2 = new Cat();
        a2.run();
//        报错，多态下不能访问子类独有功能
//        a2.bullyDog();

        System.out.println("\n多态下引用类型的强制类型转换");
//        从父类类型到子类类型，大转小→必须强制类型转换
        Dog d = (Dog) a1;
        d.run();
        d.lookDoor();
        System.out.println("-------------");
//        从父类类型到子类类型，大转小→必须强制类型转换
        Cat c = (Cat) a2;
        c.run();
        c.bullyDog();
    }
}

控制台输出结果：

 注意：如果转型后的类型和对象真实类型不是同一种类型，那么在转换的时候就会出现ClassCastException

3.instanceof关键字 

Java建议多态下的引用类型在强制类型转换的前，使用 instanceof 关键字判断当前对象的真实类型，再进行强制类型转换。

变量名 instanceof 真实类型
判断 instanceof 左边的变量指向的对象的真实类型，是否与右边的类型或者与其子类类型一样，是则返回true，反之。

        Animal a3 = new Cat();
//        强制类型转换，编译阶段不报错的（注意：继承或者实现关系编译阶段可以强制，没有毛病），运行可能出错了
//        Dog dog = (Dog)a3;
//        java建议在强制转换前使用instanceof关键字判断当前对象的真实类型，再进行强制转换
        if (a3 instanceof Cat){     //判断a3指向的是不是Cat类
            Cat cat = (Cat)a3;      //是cat，强制转换成cat类，从父类类型到子类类型大转小，必须进行强制类型转换
            cat.run();              
            cat.bullyDog();
        }else if (a3 instanceof Dog){   //反之，判断a3指向是Dog则强制转换成狗类型
            Dog dog = (Dog) a3;
            dog.run();
            dog.lookDoor();
        }
        System.out.println("-------------");

 

 

        System.out.println("-------------");
        Animal a3 = new Dog();
//        强制类型转换，编译阶段不报错的（注意：继承或者实现关系编译阶段可以强制，没有毛病），运行可能出错了
//        Dog dog = (Dog)a3;
//        java建议在强制转换前使用instanceof关键字判断当前对象的真实类型，再进行强制转换
        if (a3 instanceof Cat){     //判断a3指向的是不是Cat类
            Cat cat = (Cat)a3;      //是cat，强制转换成cat类，从父类类型到子类类型大转小，必须进行强制类型转换
            cat.run();
            cat.bullyDog();
        }else if (a3 instanceof Dog){   //反之，判断a3指向是Dog则强制转换成狗类型
            Dog dog = (Dog) a3;
            dog.run();
            dog.lookDoor();
        }
        System.out.println("-------------");

 4.知识总结：

1.引用类型的类型转换，有几种方式？

自动类型转换，强制类型转换。

2.强制类型转换能解决什么问题？需要注意什么？

可以解决多态下不能访问子类独有功能的问题，强制转换后可以访问；

有继承或者实现关系的两个类型就可以进行强制转换，编译无问题；

运行时，如果发现强制转换后的类型不是对象的真实类型则会报错；

注意：Java建议强制转换前使用instanceof关键字判断一下当前对象的真实类型，再进行强制类型转换