十四、多态
多态就是指程序中定义的引用变量所指向的具体类型和通过该引用变量发出的方法调用
在编译时并不确定，而是
在程序运行期间才确定。
即一个引用变量到底会指向哪个类的实例对象，该引用变量发出的方法调用到底是哪个类中实现的方法，必须在由程序运行期间才能决定。
因为在程序运行时才确定具体的类，这样就不用修改源程序代码，就可以让引用变量绑定到各种不同的类实现上，从而导致该引用调用的具体方法随之改变，即不修改程序代码就可以改变程序运行时所绑定的具体代码，让程序可以选择多个运行状态，这就是多态性。
14.1 多态是什么？
多态其实就是一种能力，是指同一个行为具有多个不同表现形式。换句话说就是，执行一段代码，Java 在运行时能根据对象的不同产生不同的结果。
多态的三个前提条件：
14.2 多态的体现
多态体现的格式：
父类类型 变量名 = new 子类对象；
变量名.方法名();
例：
Fu f = new Zi();
f.method()
父类类型：指子类对象继承的父类类型，或者实现的父接口类型。
当使用多态方式调用方法时，首先检查父类中是否有该方法，如果没有，则编译错误；如果有，执行的是子类重写后的方法。
/**
* @author QHJ
* @date 2022/9/21 09:01
* @description: 多态
*/
public class Dog extends Animal {
// 子类覆盖父类方法
@Override
public void eat() {
System.out.println("这是Dog类里的eat()方法");
}
public static void main(String[] args) {
// 父类引用指向子类对象
Animal[] animals = {new Animal(), new Dog()};
for(Animal animal : animals) {
// 对象是Animal的时候输出：吃吃吃
// 对象是Dog的时候输出：这是Dog类里的eat()方法
animal.eat();
}
}
}
// 定义父类
class Animal {
public void eat() {
System.out.println("吃吃吃");
}
}
14.3 多态与后期绑定
观察上面的代码，思考一个问题：在执行 animal.eat() 方法的时候，由于编译器只有一个 Animal 引用，它怎么知道究竟该调用父类 Animal 的 eat() 方法，还是子类 Dog 的 eat() 方法呢？
答案是：程序在运行时会根据对象的类型进行后期绑定，编译器在编译阶段并不知道对象的类型，但是 Java 的方法调用机制能找到正确的方法体，然后执行出正确的结果。
多态机制提供的一个好处就是程序具有良好的扩展性：
package com.qhj.polymorphism;
/**
* @author QHJ
* @date 2022/9/21 09:05
* @description: 多态的扩展性
*/
public class Dog extends Animal {
// 子类覆盖父类方法
@Override
public void eat() {
System.out.println("这是Dog类里的eat()方法");
}
// 子类覆盖父类方法
@Override
public void drink() {
System.out.println("喝喝喝");
}
public static void main(String[] args) {
// 父类引用指向子类对象
Animal[] animals = {new Animal(), new Dog()};
for (Animal animal : animals) {
// 对象是Animal的时候输出：吃吃吃
// 对象是Dog的时候输出：这是Dog类里的eat()方法
animal.eat();
}
}
}
// 定义父类
class Animal {
public void eat() {
System.out.println("吃吃吃");
}
public void drink() {
System.out.println("喝喝喝");
}
}
在 Animal 类中新增了 drink() 方法，在 Dog 类中新增了 drink() 方法，但是这丝毫不会影响到 eat() 方法的调用。eat() 方法忽略了周围代码发生的变化，依然正常运行。
多态的这个优秀特性让我们在修改代码时不必过于紧张，因为多态是一项让程序员 “将改变的与未改变的分离开来” 的重要特性。
14.4 多态与构造器
在构造器中调用多态方法：
/**
* @author QHJ
* @date 2022/9/21 09:09
* @description:
*/
public class Zhangxiaosan extends Zhangsan {
private int age = 3;
public Zhangxiaosan(int age) {
this.age = age;
System.out.println("张小三的年龄是：" + this.age);
}
@Override
public void write() {
System.out.println("张小三上幼儿园的年龄是：" + this.age);
}
public static void main(String[] args) {
new Zhangxiaosan(4);
}
}
class Zhangsan {
Zhangsan() {
System.out.println("上幼儿园之前");
write();
System.out.println("上幼儿园之后");
}
public void write() {
System.out.println("张三上幼儿园的年龄是3岁半");
}
}
输出结果：
上幼儿园之前
张小三上幼儿园的年龄是：0
上幼儿园之后
张小三的年龄是：4
因为在创建子类对象时，会先去调用父类的构造器，而父类的构造器中又调用了被子类覆盖的多态方法，由于父类并不清楚子类对象中的属性值是什么，于是就把 int 类型的属性值暂时暂时初始化为 0，然后再调用子类的构造器（子类构造器知道张小三的年龄是 4）.
14.5 多态与引用类型转换
多态的转型分为向上转型与向下转型两种。
01、向上转型
向上转型：多态本身是子类类型向父类类型向上转换的过程，这个过程是默认的。
当父类引用指向一个子类对象时，便是向上转型。
使用格式：
父类类型 变量名 = new 子类类型();
如：Animal a = new Cat();
02、向下转型
向下转型：父类类型向子类类型向下转换的过程，这个过程是强制的。
一个已经向上转型的子类对象，将父类引用转为子类引用，可以使用强制类型转换的格式，便是向下转型。
但是这并不是安全的，因为有的时候父类引用指向的是父类对象，向下转型就会抛出 ClassCastException，表示类型转换失败；但如果父类引用指向的是子类对象，那么向下转型就是成功的。
使用格式：
子类类型 变量名 = (子类类型) 父类变量名;
如:Cat c = (Cat) a;
03、为什么要转型？
当使用多态方式调用方法时，首先检查父类中是否有该方法，如果没有，则编译错误。也就是说，不能调用子类拥有、而父类没有的方法。编译都错误，更别说运行了。这也是多态给我们带来的一点"小麻烦"。所以，想要调用子类特有的方法，必须做向下转型。
//定义类
abstract class Animal {
abstract void eat();
}
class Cat extends Animal {
public void eat() {
System.out.println("吃鱼");
}
public void catchMouse() {
System.out.println("抓老鼠");
}
}
class Dog extends Animal {
public void eat() {
System.out.println("吃骨头");
}
public void watchHouse() {
System.out.println("看家");
}
}
//定义测试类
public class Test {
public static void main(String[] args) {
// 向上转型
Animal a = new Cat();
a.eat(); // 调用的是 Cat 的 eat
// 向下转型
Cat c = (Cat)a;
c.catchMouse(); // 调用的是 Cat 的 catchMouse }
}
04、转型的异常
public class Test {
public static void main(String[] args) {
// 向上转型
Animal a = new Cat();
a.eat(); // 调用的是 Cat 的 eat
// 向下转型
Dog d = (Dog)a;
d.watchHouse(); // 调用的是 Dog 的 watchHouse 【运行报错】
}
}
这段代码可以通过编译，但是运行时，却报出了 ClassCastException ，类型转换异常！这是因为，明明创建了 Cat类型对象，运行时，当然不能转换成Dog对象的。这两个类型并没有任何继承关系，不符合类型转换的定义。 为了避免ClassCastException的发生，Java提供了 instanceof 关键字，给引用变量做类型的校验，格式如下：
变量名 instanceof 数据类型
如果变量属于该数据类型，返回true。
如果变量不属于该数据类型，返回false
所以，转换前，我们好先做一个判断。
14.6 多态的好处
实际开发的过程中，父类类型作为方法形式参数，传递子类对象给方法，进行方法的调用，更能体现出多态的扩展性与便利。
//定义父类
public abstract class Animal {
public abstract void eat();
}
//定义子类
class Cat extends Animal {
public void eat() {
System.out.println("吃鱼");
}
}
class Dog extends Animal {
public void eat() {
System.out.println("吃骨头");
}
}
//定义测试类
public class Test {
public static void main(String[] args) {
// 多态形式，创建对象
Cat c = new Cat();
Dog d = new Dog();
// 调用showCatEat
showCatEat(c);
// 调用showDogEat
showDogEat(d);
/*
以上两个方法, 均可以被showAnimalEat(Animal a)方法所替代,而执行效果一致
*/
showAnimalEat(c);
showAnimalEat(d);
}
public static void showCatEat (Cat c){
c.eat();
}
public static void showDogEat (Dog d){
d.eat();
}
public static void showAnimalEat (Animal a){
a.eat();
}
}
