多态：
多态是继封装、继承之后，Java面向对象中的第三个特性。
多态是同一个行为具有多个不同表现形式或形态的能力。
同一行为，通过不同的事物，可以体现出不同的形态。
定义：
多态：是指同一行为(方法),具有多个不同的表现形式。
前提：
1.继承或者实现【二选其一】
2.方法的重写【意义体现，不重写，无意义】
3.父类引用指向子类对象【格式体现】
class Human{}
class Man extends Human{}
class Test{
public static void main(String[] args){
Human human = new Man();
}
}
多态的体现：
格式：
父类类型 变量名 = new 子类类型();
变量名.方法名();
父类类型：指子类对象继承的父类类型，或者实现的父接口类型；
如：
Fu fu = new Zi();
fu.method();
备注：当你在使用多态的时候，程序会首先检查父类中是否含有该方法，如果没有，则编译错误；
如果有该方法，执行的是子类重写之后的方法。
多态的好处：
1. 消除类型之间的耦合关系
2. 可替换性
3. 可扩展性
4. 接口性
5. 灵活性
6. 简化性
在程序开发过程中，父类类型一般作为方法的形式参数，传递子类对象给方法，进行方法的调用，
更能体现出多态的扩展性和便利性。
总结：由于多态特性的支持，它不仅仅是替代，在扩展性方面，无论之后再出现多少个子类，
我们不需要再重复定义showXxxEat()方法，直接使用showAnimalEat()方法。
所以多态的好处体现在可以使程序编写更简单，并且有良好的扩展性
引用类型转换：
多态的转型分为向上转型与向下转型两种：
向上转型：
向上转型：多态本身是子类类型向父类类型向上转换的过程，这个过程是默认的。
当父类引用指向一个子类对象的时候，便是向上转型。
格式：
父类类型 变量名 = new 子类类型();
如：Animal animal = new Cat();
向下转型：
向下转型：父类类型向子类类型向下转换的过程，这个过程是强制的。
一个已经向上转型的子类对象，将父类引用转为子类引用，
可以使用强制类型转换的格式，便是向下转型。
格式：
子类类型 变量名 = (子类类型) 父类变量名；
如 Cat cat = (Cat)animal;
为什么要转型？
当使用多态方式调用方法时，首先会检查父类中是否含有该方法，如果没有，则编译错误，
进一步说，不能直接调用子类拥有，而父类没有的方法。
所以，想要调用子类特有的方法，必须向下转型。
转型的异常：
两个类型没有任何继承关系，不符合类型转换的定义。
为了避免ClassCastException的发生，Java提供了instanceof关键字，给引用变量类型做类型的校验。
格式：
变量名 instanceof 数据类型
如果变量属于该数据类型 返回true;
如果变量不属于该数据类型 返回false。
内部类：
在描述事物时，若一个事物内部同时它还包含其他事物时，就可以使用内部类这种结构。
什么是内部类？
将一个类A定义在另一个类B里面，里面的那个类A称为内部类，类B则成为外部类。
成员内部类：
成员内部类：定义在类中方法外的类
格式：
public class OutClassName{
//......
class InnerClassName{
//......
}
//......
}
如：汽车事物和引擎事物 引擎在汽车事物的内部
public class Car{//Car就是外部类
class Engine{ //Engine 就是内部类
}
public void move(){
System.out.println("汽车在运动! ");
}
}
访问特点：
1.内部类可以直接访问外部类的成员，包括私有成员。
2.外部类要访问内部类的成员，必须要建立在内部类的对象基础上。
创建内部类对象的格式：
外部类名.内部类名 对象名 = new 外部类型().new 内部类型();
代码演示：
//定义一个外部类 Body
public class Body {
//定义身体是否还活着 私有成员变量
private boolean isLive = true;//true 代表还活着
//定义一个内部类 Heart
public class Heart{
//定义心脏跳动的功能
public void beating(){
//输出 "心脏跳动不跳动"
if(isLive){
System.out.println("心脏在跳动!");
}else {
System.out.println("心脏不跳了，抬走，下一个");
}
}
}
//提供getXxx()和setXxx()方法
public boolean isLive() {
return isLive;
}
public void setLive(boolean live) {
isLive = live;
}
}
public class TestInnerClass01 {
public static void main(String[] args) {
//创建外部类对象
Body body = new Body();
// 创建内部类对象 外部类名.内部类名 对象名 = new 外部类型().new 内部类型();
Body.Heart heart = body.new Heart();
//调用内部类方法 beating() 心脏跳动
heart.beating();
//调用外部类方法
body.setLive(false);//isLive = false
//调用内部类方法
//此时isLive修改之后的值传入到Heart类内部
heart.beating();
}
}
备注：内部类仍然是一个独立的类，在编译之后会被编译成独立的.class文件
但是.class文件的名称是：外部类名$内部类名
如：Body$Heart.class
匿名内部类 【重点】
匿名内部类：是内部类的简化写法。他的本质是一个带【具体实现的】【父类或者父接口】【匿名】子类的对象。
在开发中，最常用的内部类就是匿名内部类。
示例：
以接口举例，当你使用一个接口的时候，你需要做如下操作：
1.定义子类
2.重写接口中的方法
3.创建子类对象
4.调用重写后的方法。
我们的目的就是想调用接口中的某个方法，以上四步可以简化成一步操作
前提：
匿名内部类必须是继承一个父类或者实现一个父接口。
格式：
new 父类名或者父接口名(){
//方法的重写
@Override
public void method(){
//方法体内容
}
}
举例：
以接口为例，匿名内部类的使用。
public interface Door {
//开门功能
void openDoor();
}
public class TestInnerClass02 {
public static void main(String[] args) {
//使用接口Door中的openDoor()方法
new Door(){
//方法重写
@Override
public void openDoor() {
System.out.println("FBI，open the door!");
}
}.openDoor();
}
}