多态，引用类型转换和内部类

多态：

　　多态是继封装、继承之后，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(); 
    　　}
　　}