一、多态定义及存在条件

1.1 多态的定义

多态是什么？

  • 多态是同一个行为具有不同的表现形式或形态的能力
  • 同一方法可以根据发送对象的不同而采用不同的行为方式

例如：打印机分为黑白打印机和彩色打印机，在黑白打印机情况下打出来为黑白，在彩色打印机情况下打印出来为彩色

多态就是事物的多种形态，一个对象在不同条件下所表现的不同形式

1.2 多态的存在条件

多态存在的三个必要条件

  1. 继承或实现：在多态中必须存在有继承或实现关系的子类和父类
  2. 方法的重写：子类对父类中的某些方法进行重新定义（重写，使用@Override注解进行重写）
  3. 基类引用指向派生类对象，即父类引用指向子类对象，父类类型：指子类对象继承的父类类型，或实现的父接口类型

1.3 多态的格式

  • 父类类型 变量名 = new 子类类型（）；
  • 然后通过 变量名.方法名（）调用在子类中重写的方法
  • 多态体现为父类引用变量可以指向子类对象：定义了一个父类类型的引用，指向新建的子类类型的对象，由于子类是继承他的父类的，所以父类类型的引用是可以指向子类类型的对象的

1.4多态中的成员特点

  • 多态成员变量：编译运行看左边

此处举例Animal是父类，Dog是子类

  • Animal dog = new Dog(); //Animal是引用类型，Dog是实际类型
  • System.out.println(dog.age) //dog的引用类型是Animal,所以取到的是父类Animal中的值,说白了dog是属于Animal类，Animal中变量的值是多少就通过对象就取得多少

父类Animal:

//父类public class Animal {public int age = 11;}

子类Dog:

//子类public class Dog extends Animal {public int age = 33;}

启动项：

public class DemoApplication {public static void main(String[] args) {//父类类型 对象 = new 子类类型（）Animal dog = new Dog();System.out.println(dog.age);}}

控制台打印输出：父类中定义的age

11
  • 多态成员方法：编译看左边，运行看右边

此处举例Animal是父类，Dog是子类

  • Animal dog = new Dog（）； //Animal是引用类型，Dog是实际类型
  • dog.eat();//变量dog的实际类型是Dog,即是由Dog 这个实际类型new出来的，因此dog.eat() 调用的应该是子类Dog中重写的方法

父类Animal：

//父类public class Animal {public void eat() {System.out.println("午餐吃狗粮");}}

子类Dog:

//子类public class Dog extends Animal {@Overridepublic void eat() {System.out.println("晚餐吃狗粮");}}

启动项：

public class DemoApplication {public static void main(String[] args) {//父类类型 对象 = new 子类类型（）Animal dog = new Dog();dog.eat();}}

控制台打印输出：调用的是子类中重写的方法

晚餐吃狗粮

1.5 重写方法的快捷键

在子类Dog中右键选择Generate

选择Override Methods然后点击生成

1.6 多态的特点

  1. 多态情况下，子类和父类存在同名的成员变量时，访问的时父类的成员变量
  2. 多态情况下，子父类存在同名的非静态成员方法时，访问的是子类中重写的方法
  3. 多态情况下，子父类存在同名的静态成员变量成员方法时，访问的是父类的成员函数
  4. 多态情况下，不能访问子类独由的方法

对于子类独有的方法，父类无法访问，

父类Animal保持不变：

//父类public class Animal {public void eat() {System.out.println("午餐吃狗粮");}}

子类Dog:增加子类读有的方法walk()

//子类public class Dog extends Animal {public void walk(){System.out.println("子类独有的方法");}@Overridepublic void eat() {System.out.println("晚餐吃狗粮");}}

启动项：walk()方法爆红，即编译报错，

根据多态成员方法中编译看左边，运行看右边的原理

Animal dog = new Dog（）；

可知 左边的Animal引用类型中没有walk()这个方法，故编译不通过，编译爆红

public class DemoApplication {public static void main(String[] args) {//父类类型 对象 = new 子类类型（）Animal dog = new Dog();dog.eat();//访问的是子类中重写的方法dog.walk();//walk方法爆红,即编译报错，编译看左边，dog类的实例对象Animal没有walk（）这个方法，所以编译报错}}

那么想要直接访问子类独有的方法，该如何解决呢，由此引出了引用类型转换

二、引用类型转换

2.1 为什么需要引用类型转换

  • 上面的例子说明了，在多态情况下，使用Animal引用类型构建出来的对象dog无法访问子类Dog所独有的方法walk（）；强行调用时方法会爆红，编译出错，即我们所说的编译看左边，运行看右边
  • 而且我们在多态情况下调用方法时，首先会检查等式左边的引用类型（父类）中是否有该方法存在，如果父类中没有该方法，则编译器直接报错，也就代表着，父类无法调用子类独有的方法
  • 既然编译都出错了，更别说运行了，这也是多态所造成的，因此如果我们想要调用子类的方法，必须做到向下转型

2.2 向上转型（自动转换）

先了解什么向上转型（儿子变父亲）

向上转型：

多态本身是子类向父类向上转换（自动转换）的过程，这个过程是默许的，当父类引用指向一个子类对象时，就是向上转型

父类引用指向子类对象：

Animal dog = new Dog（）

左边的Animal是引用类型，而dog是由右边的Dog实例对象new出来的，在上面这个等式中，左边的引用Animal指向了子类的对象dog，原本是子类对象的dog完成了向上转型

对于父类和子类的关系，直接用图来描述

Animal父类是大范围的类型，而Cat和Dog类均属于动物类的子类，所以对于子类这种范围小的，我们可以自动转型给父类的变量，儿子向上转型，父亲是唯一的，因此是自动转换

使用格式：

父类类型 变量名 = new 子类类型（）；

Animal dog=new Dog（）

通过由实例变量Dog类new出来的变量dog作为中介，使得引用变量Animal有所指向，从而完成了向上转型

相当于是

Animal dog= （Animal) new Dog（）

2.3 向下转型（父亲变儿子，需要强制转换）

向上转型是一个子类变成父类的过程，下面介绍向下转型

向下转型：

向下转型是父类向子类转换的过程，这个过程需要强制转换（父亲变儿子肯定是需要条件的），一个可以将父类对象转换为子类对象，可以使用强制类型转换的格式，这便是向下转型

继续拿图说话

对于Dog、Cat这些子类来说，他们只是父类Animal的一部分，而对于父类来说。他拥有更多的子类 牛、羊等，所以一旦父类要转换成子类，就必须指定要变成哪个子类，必须有指向性，所以向下转型才是强制转换

使用格式：

向上转型

父类类型 变量名 = new 子类类型（）；

Animal dog=new Dog（）

向下转型

子类类型 子类变量名 = （子类类型） 父类变量名

Dog dog1 = (Dog) dog;

dog1.walk； //此时可以使用子类独有的方法了

代码示例如下：

父类Animal:

//父类public class Animal {public void eat() {System.out.println("午餐吃狗粮");}}

子类Dog：包含有子类独有的方法walk()

//子类public class Dog extends Animal {public void walk(){System.out.println("子类独有的方法");}@Overridepublic void eat() {System.out.println("晚餐吃狗粮");}}

启动项：

通过

Dog dog1 = (Dog) dog;完成向下转型

再利用向下转型成功的子类对象dog1调用子类中独有的方法walk()

public class DemoApplication {public static void main(String[] args) {//父类类型 对象 = new 子类类型（）Animal dog = new Dog();//向下转型//子类类型 子类变量名 = （子类类型） 父类变量名Dog dog1 = (Dog) dog;dog.eat();//访问的是子类中重写的方法//通过向下转型的子类对象调用子类独有的方法dog1.walk();//walk方法爆红,即编译报错，编译看左边，dog类的实例对象Animal没有walk（）这个方法，所以编译报错}}

控制台打印输出：

晚餐吃狗粮子类独有的方法

所以对于多态中，无法使用子类特有的方法也通过向下转型，将父类类型强制转换为某个子类类型后，再进行方法的调用

2.4 向下转型的问题

虽然可以通过向下转型可以调用子类独有的方法，但也会产生下面的问题

增加一个子类Cat类，

Cat类中有其独有的方法sleep（）

//Cat类通过extends关键字继承父类Animalpublic class Cat extends Animal {public void sleep(){System.out.println("Cat类独有的方法");}@Overridepublic void eat() {System.out.println("晚餐吃猫粮");}}

父类Animal：

//父类public class Animal {public void eat() {System.out.println("午餐吃狗粮");}}

子类Dog类：

//子类public class Dog extends Animal {public void walk(){System.out.println("Dog类独有的方法");}@Overridepublic void eat() {System.out.println("晚餐吃狗粮");}}

启动项：

public class DemoApplication {public static void main(String[] args) {//向上转型//父类类型 对象 = new 子类类型（）Animal cat = new Cat();//向下转型//子类类型 子类变量名 = （子类类型） 父类变量名Dog dog1 = (Dog) cat;//通过向下转型的子类对象调用子类独有的方法dog1.walk();//walk方法爆红,即编译报错，编译看左边，dog类的实例对象Animal没有walk（）这个方法，所以编译报错}}

控制台打印输出：爆出异常ClassCastException，即类型转换异常

分析：为什么会爆出类型转换异常

  • 因为 在启动项中，向上转型的过程，Animal cat = new Cat(); cat对象是由子类Cat构造出来的
  • 而向下转型的过程中Dog dog1 = (Dog) cat; 却将其变成了Dog 类的对象，
  • Dog类和Cat类都是Animal类的儿子类 ，
  • 上面的步骤中的第二步将子类Cat的对象cat变成了兄弟类的对象dog,这就不是向下转型了，因此会报类型转换异常

那么如何避免这种异常呢 ，就需要使用instanceof关键字

2.5 instanceof关键字详解

Java为我们提供了一个关键字instanceof,它可以帮助我们避免出现ClassCastException这样的异常，

格式：

变量名 instanceof 数据类型

解释：

  • 如果变量属于该数据类型或者其子类型，返回true
  • 如果变量不属于该数据类或者其子类型，返回false

直接拿启动项来进行说明，

代码示例如下：

public class DemoApplication {public static void main(String[] args) {//向上转型//父类类型 对象 = new 子类类型（）Animal animal = new Cat();//向下转型//子类类型 子类变量名 = （子类类型） 父类变量名if ( animal instanceof Cat){Cat cat = (Cat) animal;cat.sleep();}else if(animal instanceof Dog){Dog dog = (Dog) animal;dog.walk();}}}

在进行了向上转型之后，在向下转型的过程中利用if语句来进行判断，而判断条件正是向上转型产生的变量与子类之间的关系

控制台打印输出：

Cat类独有的方法