# 多态
[TOC]
## 导学
本章节，我们将要学习面向对象三大特性之一的多态，所谓的多态，字面意义来看就是多种形态。它是面向对象程序设置的最核心的特征。从某种意义上来讲，封装和继承都是为了多态而准备的。
## 多态的概念
在现实生活中，动物都有吃东西，跑和跳等通用的行为能力，但是不同的动物针对行为的表现形式是不同的。比如猫，狗，兔子喜欢吃的东西各有不同，而叫声也是不一样的。
再比如键盘上的`f1`键，在eclipse的界面会唤出eclipse的帮助文档，在word的界面会唤出word的帮助文档，在Windows系统下回唤出Windows的帮助文档。可以看到同样的行为在不同的对象上会产生不同的形式结果，这就是生活中的多态。
在程序中：
>[info]多态意味着允许不同类的对象对同一消息作出不同的响应。
在Java中，多态在广义上来说可以分为编译时多态（方法的多态性）和运行时多态（对象的多态性）。
~~~
1. 编译时多态（也叫设计时多态，通过方法重载实现）
2. 运行时多态（程序运行时动态决定调用哪个方法）
~~~
在Java中指的多态，大多指的是运行时多态（狭义上的多态）。
多态实现的具体条件在于：
1. 满足继承关系
2. 父类引用指向子类对象
那么，什么是父类引用指向子类对象呢？接下来通过具体代码来看看吧
## 多态的实现
### 场景描述及实体类编写
~~~
package com.dodoke.proJ.animal;
public class Animal {
//属性：昵称、年龄
private String name;
private int month;
//方法：吃东西
public void eat() {
System.out.println("动物都有吃东西的能力");
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getMonth() {
return month;
}
public void setMonth(int month) {
this.month = month;
}
public Animal(String name, int month) {
super();
this.name = name;
this.month = month;
}
public Animal() {
super();
}
}
~~~
~~~
package com.dodoke.proJ.animal;
public class Cat extends Animal {
//属性：体重
private double weight;
//方法：跑动
public void run() {
System.out.println("小猫快乐的奔跑");
}
//方法：吃东西
@Override
public void eat() {
System.out.println("猫吃鱼~");
}
public double getWeight() {
return weight;
}
public void setWeight(double weight) {
this.weight = weight;
}
public Cat() {
super();
}
public Cat(String name, int month, double weight) {
super(name, month);
this.weight = weight;
}
}
~~~
~~~
package com.dodoke.proJ.animal;
public class Dog extends Animal{
//属性：性别
private String sex;
//方法：睡觉
public void sleep() {
System.out.println("小狗有午睡的习惯");
}
//方法：吃东西
@Override
public void eat() {
System.out.println("狗吃肉~");
}
public String getSex() {
return sex;
}
public void setSex(String sex) {
this.sex = sex;
}
public Dog() {
super();
}
public Dog(String name, int month, String sex) {
this.setMonth(month);
this.setMonth(month);
this.sex = sex;
}
}
~~~
**多态是指编译时类型和运行时类型不一致**
>[warning] Java引用类型变量有两种类型：一种是编译时类型，一种是运行时类型
* 编译的类型是由声明变量的时候确定的
* 运行时的类型是由实际上赋给该变量的对象决定的
~~~java
//比如声明变量类型为Animal，实际赋给该变量的对象类型为Dog
Animal animal = new Dog();
~~~
### 向上转型
**向上转型是指父类引用指向子类的实例**
通常也称向上转型为隐式转型和自动转型。通俗来说，是子类转型为父类，小类转型为大类。
~~~
public class Test {
public static void main(String[] args) {
//animal的引用 = 具体的animal实例
Animal one = new Animal();
Animal two = new Cat();
Animal three = new Dog();
one.eat();
two.eat();
three.eat();
one.getMonth();
two.getName();
//three.sleep();
}
}
~~~
>[success]父类引用指向子类实例，可以调用子类重写父类的方法以及父类派生的方法，但是无法调用子类独有方法！
>[warning]父类中的静态方法无法被重写，所以向上转型后，只能调用到父类原有的静态方法
### 向下转型
**向下转型指的是子类引用指向父类对象**
向下转型又称之为强制类型转换，通俗来讲就是父类转型为子类，大类转为小类。对比之前的基本数据类型转换，数据范围大的类型转为数据范围小的类型就需要进行强制类型转换，引用数据类型也是如此。
~~~
public class Test {
public static void main(String[] args) {
//animal的引用 = 具体的animal实例
Animal one = new Animal();
Animal two = new Cat();
Animal three = new Dog();
one.eat();
two.eat();
three.eat();
one.getMonth();
two.getName();
//three.sleep();
System.out.println("=======================================");
Cat temp = (Cat)two;
temp.eat();
temp.run();
temp.getMonth();
/**
* 此处的代码不能进行强制类型转换
* 原因：two这个对象定义的时候，实际上指向的是Cat这个类型的空间
* Cat temp = (Cat)two; 相当于把two对象还原成原来的实例空间。
* 但是狗和猫并没有兼容的关系，只是拥有同一个父类而已，是兄弟关系
*/
Dog temp1 = (Dog)two;//必须满足转型条件才能转换
temp1.eat();
temp1.sleep();
temp1.getMonth();
System.out.println("程序继续执行");
}
}
~~~
**比较：**
| 向上转型 | 向下转型 |
| --- | --- |
| 又称隐式转型、自动转型 | 又称强制类型转换 |
| 父类引用指向子类实例，可以调用子类重写父类的方法以及父类派生的方法，无法调用子类独有方法 | 子类引用指向父类对象，此处必须进行强制转换，可以调用子类特有的方法 |
| 小类转为大类 | 必须满足转型条件才能进行转换 |
### instanceof关键字
在之前的章节中，我们提到向下转型需要满足转型条件，那么我们该如何才能知道是否满足转型条件呢
这时候，`instanceof`关键字就派上用处了！
`instanceof`关键字用于判断左边的对象是否满足右边的实例。如果满足返回`true`，否则返回`false`。
~~~
public class Test {
public static void main(String[] args) {
//animal的引用 = 具体的animal实例
Animal one = new Animal();
Animal two = new Cat();
Animal three = new Dog();
one.eat();
two.eat();
three.eat();
one.getMonth();
two.getName();
//three.sleep();
System.out.println("=======================================");
if(two instanceof Cat) {
Cat temp = (Cat)two;
temp.eat();
temp.run();
temp.getMonth();
System.out.println("two可以转换为Cat类型");
}
if(two instanceof Dog) {
Dog temp1 = (Dog)two;
temp1.eat();
temp1.sleep();
temp1.getMonth();
System.out.println("two可以转换为Dog类型");
}
if(two instanceof Animal) {
System.out.println("Animal");
}
if(two instanceof Object) {
System.out.println("Object");
}
//所以two对象具有Animal类型和Object类型的特征
System.out.println("程序继续执行");
}
}
~~~
### 类型转换案例
#### 案例
在原有的项目中，增加一个主人类。在猫类中添加玩线球方法
~~~
public class Master {
/**
* 喂宠物：
* 喂猫咪：吃完东西后，主人会带着去玩线球
* 喂狗狗：吃完东西后，主人会带着去睡觉
* 养兔子、样鹦鹉、养乌龟
*/
//方案一：编写方法，传入不同类型的动物，调用各自的方法
public void feed(Cat cat) {
cat.eat();
cat.palyBall();
}
public void feed(Dog dog) {
dog.eat();
dog.sleep();
}
//方案二：编写方法传入动物的父类，方法中通过类型转换，调用指定的子类的方法
public void feed(Animal ani) {
if(ani instanceof Cat) {
Cat cat = (Cat)ani;
cat.eat();
cat.palyBall();
} else if(ani instanceof Dog) {
Dog dog = (Dog)ani;
dog.eat();
dog.sleep();
}
}
}
~~~
多个对象要实现一个方法吃的时候，一般的解决方法是写重载函数。
而新的解决方法是用一个方法传参的时候先向上转化成父类， 然后再根据实际情况进行判断后，转化成原来的类型 ，在调用自己本身的方法 （向下转型）
#### 新增需求
针对主人空闲时间的判断，如果时间多则养狗，如果时间少则养猫。
~~~
package com.dodoke.proJ.animal;
public class Master {
//方案一
public Dog hasManyTime() {
System.out.println("主人空闲时间充足，适合养狗狗");
return new Dog();
}
public Cat hasLittleTime() {
System.out.println("主人空闲时间比较少，适合养猫咪");
return new Cat();
}
//方案二
public Animal raise(boolean isManyTime) {
if(isManyTime) {
System.out.println("主人空闲时间充足，适合养狗狗");
return new Dog();
} else {
System.out.println("主人空闲时间比较少，适合养猫咪");
return new Cat();
}
}
}
~~~
在方法内部实现多态。返回值为子类对象，由父类引用接收。相当于Animal animal=new Cat();向上转型。
当我们在实际开发当中需要同一个操作行为，针对不同的参数， 返回不同的实例对象，完成不同的操作结果的时候，就比较适用于这种多态的操作。类型转换的优势就会充分体现出来了。
## 抽象类
在之前的代码中，我们创建了一个动物类。接下来，我们来看看这段代码
~~~
Animal pet = new Animal("花花",2);
pet.eat();
~~~
针对于这样的代码，编译运行都没有什么问题，但是它在实际的开发中并没有有效的意义。每个动物都应该有具体的吃东西的行为，实例化pet对象没有意义。实际的开发中会指代具体的猫还是狗来完成指代。如上的代码并不符合程序的逻辑。
那么，该如何限制程序员写这些没有意义的代码呢？
我们可以使用`abstract`关键字来限制类的实例化。
>[danger]`abstract` 是不能修饰成员变量的；
### 抽象类
~~~
public abstract class Animal {}
abstract public class Animal {}
~~~
抽象数据类型： 在类的定义前加上 `abstract` 关键字，使得该类成为一个抽象类
**抽象类不允许被实例化**，但是可以通过向上转型，指向子类实例，调用子类重写父类的方法以及父类派生的方法
`public` 与 `abstract `可以互换，但是却不能 与class关键字相互换位。
抽象类利用子类与父类的继承关系，既限制了子类的设计随意性，又避免了父类无意义的实例化。
>[info]应用场景：某个父类只是知道其子类应该包含怎样的方法，但无法准确知道这些子类如何实现这些方法
### 抽象方法
~~~
public abstract class Animal {
//属性：昵称、年龄
private String name;
private int month;
/**
* 抽象方法：没有方法体，在子类中必须重写抽象方法，如果子类不重写，则子类只能设置为抽象类
*/
public abstract void eat();
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getMonth() {
return month;
}
public void setMonth(int month) {
this.month = month;
}
public Animal(String name, int month) {
super();
this.name = name;
this.month = month;
}
public Animal() {
super();
}
}
~~~
含有抽象方法的类，只能被定义为抽象类。抽象类中不一定含有抽象方法。
在抽象类中的成员方法可以包括一般方法和抽象方法。
抽象类不能实例化，即使抽象类中不包含抽象方法，这个抽象类也不能创建实例。
一个类继承抽象类后，必须实现其所有的抽象方法，否则也是抽象类，不同的子类对父类的抽象方法可以有不同的实现。
>[warning]如果方法定义为 static，就不能使用 abstract 修饰符；
如果方法定义为 private ，也不能使用 abstract 修饰符；
抽象类体现的是一种模板模式的设计思想，抽象类作为多个子类的通用模板，子类在抽象的基础上进行扩充，但是子类整体上会保留抽象类的行为方法（必须要实现抽象类的抽象方法）。
抽象类一般只是定义需要使用的方法，把不能实现的部分抽象成抽象方法，留给子类去实现。
父类中可以有实现的方法，但是子类也是可以对已经实现的方法进行改造的（override），但是如果在子类中还需要调用父类的实现方法，可以使用 super 关键字。
## 练习
一、选择
1. 下列代码的运行结果为：
~~~
A. 我是动物
B. 编译错误
C. 我是动物
我是老虎
我是哈士奇
D. 我是动物 我是老虎 我是哈士奇
~~~
2. 创建一个父类Animal，一个子类Cat，Animal three = new Cat();不是
~~~
A. 向上转型
B. 自动转型
C. 向下转型
D. 隐式转型
~~~
3. 下列代码怎么修改可以使其成功运行：
~~~
A. 删除掉标注3位置的one.fly( )
B. 标注1的Animal one=new Bird()修改为Animal one=new Animal()
C. 删除掉标注2位置的one.eat( )
D. 标注1的Animal one=new Bird()修改为Bird one=new Animal()
~~~
4. 下列关于instanceof说法不正确的是
~~~
A. instanceof 的返回值为true和false
B. instanceof可以用来判断对象是否可满足某个特定类型
C. 可以通过“A instanceof B"表示 A 类可以转型为B类
D. instanceof可放在if语句的条件表达式中
~~~
5. 已知父类Person,子类Man。判断类Person的对象person1是否满足类Man的实例特征，正确的语句为
~~~
A. if (person1 instanceof Man)
B. if (man1 instanceof Person)
C. if (Person instanceof man1)
D. if (Man instanceof person1)
~~~
6. 在Java中，多态的实现不仅能减少编码的工作量，还能大大提高程序的可维护性及可扩展性，那么实现多态的步骤包括以下几个方面除了
~~~
A. 子类重写父类的方法
B. 子类方法设置为final类型
C. 定义方法时，把父类类型作为参数类型；调用方法时，把父类或子类的对象作为参数传入方法
D. 运行时，根据实际创建的对象类型动态决定使用哪个方法
~~~
7. 下面代码运行测试后，出现的结果是
~~~
A. 编译错误，错误位置在第一行
B. 编译错误，错误位置在第二行
C. 第一行和第二行都运行成功，输出结果为
儿子
女儿
D. 编译成功，但运行报错，错误位置在第二行
~~~
8. 下面代码怎么修改可以编译时不报错（多选）
~~~
A. 在位置一处将SpeedBike类设为抽象类，同时将位置2处的speedup也设为抽象方法
B. 将位置一中的public改为final
C. 将位置二中speedup()方法改为抽象方法
D. 将位置二中speedup()方法中加入方法的实现
~~~
9. 下列选项中，关于Java的抽象类和抽象方法说法不正确的是
~~~
A. 抽象类和抽象方法都通过abstract关键字来修饰
B. 抽象类中必须包含抽象方法
C. 抽象方法只有方法声明，没有方法实现
D. 子类如果不重写父类所有的抽象方法，则必须设置为抽象类
~~~
二、编程
1. 应用继承和多态的思想，编写动物类，成员方法是动物叫声。写三个具体的类（猫、狗、羊），它们都是动物类的子类，并重写父类的成员方法。编写测试类，随机产生三种具体动物，调用叫声这个方法。
程序参考运行效果如图所示：
**任务分析：**
**1. 定义一个父类Animal类**
属性：kind(种类)
方法：创建带参（kind为参数）构造方法
创建cry():void方法
**2. 编写三个具体的子类Cat类、Dog类、Sheep类**
分别重写父类中的 cry() 方法，输出信息分别为
Cat类：小猫的叫声：喵喵喵~~~
Dog类：小狗的叫声：汪汪汪~~~
Sheep类：小羊的叫声：咩咩咩~~~
**3. 编写测试类，首先生成长度为5的父类对象数组，然后通过循环依次向数组中存入数据，现设定存储规则为：**
a) 每次随机产生一个0~2的正整数
b) 若数值为 0，则生成一个 Cat 类的对象，存入数组
c) 若数值为 1，则生成一个 Dog 类的对象，存入数组
d) 若数值为 2，则生成一个 Sheep 类的对象，存入数组
最后循环输出数组成员，并分别调用 cry() 方法。
