## 1、多态
多态是同一个行为具有多个不同表现形式或形态的能力。
### 多态存在的三个必要条件
* 继承
* 重写
* 父类引用指向子类对象
### 1.1 代码实现
```
public class Animal {
public void eat() {
System.out.println("动物都有吃东西的能力");
}
}
public class Cat extends Animal {
public void run () {
System.out.println("小猫快乐的奔跑");
}
@Override
public void eat() {
System.out.println("小猫吃鱼～～～");
}
}
public class Dog extends Animal {
public void sleep() {
System.out.println("小狗睡觉～～～");
}
@Override
public void eat() {
System.out.println("小狗吃骨头～～～");
}
}
```
### 1.2 向上转型
向上转型即父类引用指向子类实例。
```
public class Test {
public static void main(String[] args) {
Animal a1 = new Animal();
// 向上转型、隐式转型、自动转型
Animal a2 = new Cat();
Animal a3 = new Dog();
a1.eat(); // 动物都有吃东西的能力
a2.eat(); // 小猫吃鱼～～
a3.eat(); // 小狗吃骨头～～～
}
}
```
【选择】创建一个父类`Animal`，一个子类`Cat`，`Animal three = new Cat();`不是（）（选择一项）
```
A 向上转型 B 自动转型 C 向下转型 D 隐式转型
```
【选择】下列代码怎么修改可以使其成功运行（）（选择一项）
```
public class Animal {
public void eat() {
System.out.println("动物吃～～～");
}
}
public class Bird extends Animal {
public void eat() {
System.out.println("鸟吃虫子～～～");
}
public void fly() {
System.out.println("鸟儿正在飞");
}
}
public class Test {
public static void main(String[] args) {
Animal one = new Bird(); // 1
one.eat(); // 2
one.fly(); // 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();
```
### 1.3 向下转型
向下转型（强制类型转换）即子类引用指向父类实例，需要强制类型转换。
```
Cat temp = (Cat) animal;
```
【选择】阅读以下代码，横线处填写（）无法在控制台输出“无忧无虑“（选择两项）
```
class Animal {
public void set() {
System.out.println("香甜可口");
}
}
class Fish extends Animal {
public void swim() {
System.out.println("自由自在");
}
}
class Roo extends Animal {
public void leap() {
System.out.println("无忧无虑");
}
}
public class Test {
public static void main(String[] args) {
_______________________
}
}
```
```
A Roo one = new Roo(); one.leap();
B Animal one = new Roo(); ((Roo) one).leap();
C Roo one = new Animal(); one.leap();
D Animal one = new Animal(); Roo roo = new (Roo) one; one.leap();
```
### 1.4 `instanceof`运算符
```
// 用于判断 obj 是否是 Classname 的实例或者是派生类实例
boolean flag = obj instanceof Classname;
```
【选择】阅读下列 Java 代码，横线处应该填写（）能在控制台正确输出“汪汪汪“（选择一项）
```
class Animal {}
class Dog extends Animal {
public void shout() {
System.out.println("汪汪汪");
}
}
class Roo extends Animal {
public void leap() {
System.out.println("无忧无虑");
}
}
class Manager {
public void play(Animal animal) {
(1)
}
}
public class Test {
public static void main(String[] args) {
(2)
new Manager().play(animal);
}
}
```
```
A (1) (Dog) animal.shout();
(2) Animal animal = new Dog();
B (1) if(animal instanceof Dog) { ((Dog) animal).shout(); }
else { ((Roo) animal).leap(); }
(2) Animal animal = new Animal();
C (1) if(animal instanceof Dog) { ((Dog) animal).shout(); }
else { ((Roo) animal).leap(); }
(2) Animal animal = new Dog();
D (1) if(animal instanceof Dog) { ((Dog) animal).shout(); }
else { ((Roo) animal).leap(); }
(2) Animal aniaml = new Roo();
```
【选择】下列关于 instanceof 说法不正确的是（）（选择一项）
```
A instanceof 的返回值为 true 和 false
B instanceof 可以用来判断对象是否可满足某个特定类型
C 可以通过"A instanceof B"表示 A 类可以转型为B类
D instanceof 可放在if语句的条件表达式中
```
【选择】已知父类 Person，子类 Man。判断 Person 的对象person是否满足类 Man 的实例特征，正确的语句为（）（选择一项）
```
Person person = new Man();
Man man = new Man();
```
```
A if (person instanceof Man)
B if (man instanceof Person)
C if (Person instanceof man)
D if (Man instanceof person)
```
【选择】在 Java 中，多态的实现不仅能减少编码的工作量，还能大大提高程序的可维护性及扩展性，那么实现多态的步骤包括以下几个方面除了（）（选择一项）
```
A 子类重写父类的方法
B 子类方法设置为final类型
C 定义方法时，把父类类型作为参数类型；调用方法时，把父类或子类的对象错位参数传入方法
D 运行时，根据实际创建的对象类型动态决定使用哪个方法
```
【编程】应用继承和多态的思想，编写动物类，成员方法是动物叫声。写三个具体的类（猫，狗，羊），它们都是动物类的子类，并重写父类的成员方法。编写测试类，随机产生三种具体动物，调用叫声这个方法。程序参考运行效果图如下：
```
小羊的叫声：咩咩咩～～～
小狗的叫声：汪汪汪～～～
小羊的叫声：咩咩咩～～～
小狗的叫声：汪汪汪～～～
小羊的叫声：咩咩咩～～～
```
```
public class Test {
public static void main(String[] args) {
// 生成父类对象数组，数组长度为 5
// 产生随机数，随机产生三种具体子类的实例
// 循环输出，循环体中每个对象分别调用 cry() 方法
}
}
public class Animal {
// 属性：kind(种类)
public Animal() {}
// 创建带参（kind 为参数）构造函数
// 应用封装实现对私有属性的get/set操作
// 创建成员方法cry():void
}
public class Cat extends Animal {
// 重写父类 cry
}
public class Dog extends Animal {
// 重写父类 cry
}
public class Sheep extends Animal {
// 重写父类 cry
}
```
- 阶段一 Java 零基础入门
- 步骤1：基础语法
- 第01课 初识
- 第02课 常量与变量
- 第03课 运算符
- 第04课 选择结构
- 第05课 循环结构
- 第06课 一维数组
- 第08课 方法
- 第09课 数组移位与统计
- 第10课 基础语法测试
- 第09课 基础语法测试（含答案）
- 步骤2：面向对象
- 第01课 类和对象
- 第02课 封装
- 第03课 学生信息管理
- 第04课 继承
- 第05课 单例模式
- 第06课 多态
- 第07课 抽象类
- 第08课 接口
- 第09课 内部类
- 第10课 面向对象测试
- 第10课 面向对象测试（含答案）
- 步骤3：常用工具类
- 第01课 异常
- 第02课 包装类
- 第03课 字符串
- 第04课 集合
- 第05课 集合排序
- 第06课 泛型
- 第07课 多线程
- 第08课 输入输出流
- 第09课 案例：播放器
- 第10课 常用工具测试（一）
- 第10课 常用工具测试（一）（答案）
- 第10课 常用工具测试（二）
- 第10课 常用工具测试（二）（答案）
- 阶段二 从网页搭建入门 JavaWeb
- 步骤1：HTML 与 CSS
- 第01课 HTML 入门
- 第01课 HTML 入门（作业）
- 第02课 CSS 入门
- 第02课 CSS 入门（作业）
- 第03课 CSS 布局
- 第03课 CSS 布局（作业）
- 步骤2：JavaScript 与前端案例
- 第01课 JavaScript 入门
- 第01课 JavaScript 入门（作业）
- 第02课 仿计算器
- 第03课 前端油画商城案例
- 第04课 轮播图
- 第05课 网页搭建测试
- 第05课 网页搭建测试（含答案）
- 步骤3：JavaScript 教程
- 入门
- 概述
- 基本语法
- 数据类型
- 概述
- 数值
- 字符串
- undefined, null 和布尔值
- 对象
- 函数
- 数组
- 运算符
- 算术运算符
- 比较运算符
- 布尔运算符
- 位运算符
- 运算顺序
- 语法专题
- 数据类型的转换
- 错误处理机制
- 标准库
- String
- Date
- Math
- DOM
- 概述
- Document 节点
- 事件
- EventTarget 接口
- 事件模型
- 常见事件
- 阶段三 数据库开发与实战
- 步骤1：初始数据库操作
- 第01课 数据类型
- 第02课 表的管理
- 第03课 数据管理
- 第04课 常用函数
- 第05课 JDBC 入门
- 第06课 Java 反射
- 第07课 油画商城
- 第08课 数据库基础测试
- 步骤2：MyBatis 从入门到进阶
- 第01课 IntelliJ IDEA 开发工具入门
- 第02课 Maven 入门
- 第03课 工厂模式
- 第04课 MyBatis 入门
- 第05课 MyBatis 进阶
- 第06课 商品信息管理
- 第07课 MyBatis 基础测试
- 步骤3：Redis 数据库与 Linux 下项目部署
- 第01课 Linux 基础
- 第02课 Linux 下 JDK 环境搭建及项目部署
- 第03课 Redis 入门
- 阶段四 SSM 到 Spring Boot 入门与综合实战
- 步骤1：Spring 从入门到进阶
- 第01课 Spring 入门
- 第02课 Spring Bean 管理
- 第03课 Spring AOP
- 第04课 基于 AspectJ 的 AOP 开发
- 第05课 JDBC Template
- 第06课 Spring 事务管理
- 第07课 人员管理系统开发
- 第08课 Spring 从入门到进阶测试
- 步骤2：Spring MVC 入门与 SSM 整合开发
- 第01课 Spring MVC 入门与数据绑定
- 第02课 Restful 风格的应用
- 第03课 SpringMVC 拦截器
- 第04课 办公系统核心模块
- 步骤3：Spring Boot 实战
- 第01课 Spring Boot 入门
- 第02课 校园商铺项目准备
- 第03课 校园商铺店铺管理
- 第04课 校园商铺商品管理及前台展示
- 第05课 校园商铺框架大换血
- 步骤4：Java 面试
- 第01课 面试准备
- 第02课 基础面试技巧
- 第03课 Web基础与数据处理
- 第04课 主流框架