Day_10【接口、多态】

今日内容
    接口
    多态

接口（interface）
    接口是有一种公共的规范标准。

    定义格式：
        public interface 接口名 {

        }

        接口名的命名规范和类名一致

    接口中的内容
        如果是Java 7，那么接口中可以包含的内容有：
        1. 常量
        2. 抽象方法

        如果是Java 8，还可以额外包含有：
        3. 默认方法
        4. 静态方法

        如果是Java 9，还可以额外包含有：
        5. 私有方法


       注意：接口中不能有变量和构造方法

接口中的抽象方法
    定义格式：
        public abstract 返回值类型 方法名(参数);

        接口中的抽象方法有默认修饰符：public abstract，即使不写默认也有
        抽象类中的抽象方法没有默认修饰符，如果是抽象方法就必须加上abstract


    接口的使用步骤：
        （1）不能直接创建对象，编写一个实现类去实现该接口
            实现的格式：
                public class 实现类名 implements 接口 {

                }

        （2）实现类要实现接口的所有的抽象方法
            一个类去实现接口必须实现其中的所有抽象方法，否则该实现类必须声明为抽象类。

        （3）在测试类中创建实现类的对象，使用



  练习：
        （1）掌握如何定义接口
        （2）掌握如何在接口中定义抽象方法，以及抽象方法的特点
        （3）使用接口
            三个步骤

        定义一个接口，名为Animal，其中有两个方法分别是eat()和sleep()
        编写实现类Dog实现Animal接口，最后定义一个测试类，创建Dog类的对象
        调用eat()和sleep()方法。

接口中的默认方法
    格式：
        public default 返回值类型 方法名(参数) {

        }

    默认方法中的public可以省略，但是default不能省略
    默认方法可以被实现类型创建对象直接调用，也可以被实现类重写

接口中的静态方法
    格式：
        public static 返回值类型 方法名(参数) {

        }

    使用格式：
        接口名.静态方法名();

        注意：不能通过实现类的对象来调用接口中的静态方法

 练习：
        （1）在接口中定义一个默认方法，并使用
        （2）在接口中定义一个静态方法，并使用

接口中的私有方法
    普通私有方法，多个默认方法重复代码的问题
        private 返回值类型 方法名(参数列表){

        }
    静态私有方法
        private static 返回值类型 方法名(参数列表){

        }

接口中的常量
    常量分类
        字面值常量
            整数常量        10,-5
            浮点数常量       2.5
            字符常量        'a'
            布尔常量        true false
            字符串常量       "abc"
            空常量           null

        自定义常量
            通过final关键字定义


    格式：
        public static final 数据类型 常量名 = 值;

        (1)接口中的常量有默认修饰符:public static final ，即使不写默认也有
        (2)常量的命名规范：都是大写字母组成，如果有多个单词组成，每个单词之间用下划线(_)隔开
        (3)常量必须赋值
        (4)由于接口中的常量是static修饰的，所以使用的时候可以直接“接口名.常量”的方式使用

    一个类在继承一个类的同时，还可以实现多个接口
        类与类之间是继承关系，单继承，不支持多继承，支持多层继承
        类与接口是实现关系，多实现
        接口与接口之间是继承关系，多继承

        class A extends B implements C,D {
        }

 练习：
        分别编写一个MyInterface、MyInterfaceA和MyInterfaceB接口
        MyInterfaceA有一个methodA方法
        MyInterfaceB有一个methodB方法
        MyInterface有一个method方法
        让MyInterface去同时继承MyInterfaceA和MyInterfaceB
        最后编写一个实现类MyInterfaceImpl去实现MyInterface接口

多态
    什么是多态
        现实中指的是，事物的多种形态

        白居易：横看成岭侧成峰，远近高低各不同

        在Java中的多态，指的是对象的多种形态

    多态的前提：
        （1）有继承或者实现关系
        （2）方法重写
        （3）父类的引用指向子类的对象，父接口的引用指向实现类的对象

        // 父类
        class Animal {
            public void eat(){
                System.out.println("吃...");
            }
        }
        // 子类，（1）有继承关系
        class Dog extends Animal{
            // （2）方法重写
            public void eat(){
                System.out.println("狗吃骨头");
            }
        }

        public class Test{
            public static void main(String[] args){
                // Dog d = new Dog();
                // （3）父类的引用指向子类的对象
                Animal a = new Dog();
            }
        }

    多态格式：
        父类类名【父接口名】 对象名 = new 子类类名【实现类名】();
        例如：Animal a = new Dog();

    多态下成员方法调用的特点：
        编译看左边（父类），运行看右边（子类）
        编译的时候看父类中是否有这个方法，如果没有编译就报错，如果有，运行的时候执行的子类中的方法

引用数据类型的转换
    向上转型：小的类型（子类或者实现类）转为大的类型（父类或者接口），其实多态就是一种向上转型
    向下转型：大的类型（父类或者接口）转为小的类型（子类或者实现类）
        格式：
            小的类型 变量名 = (小的类型)大的类型的数据;

基本数据类型的转换
    隐式转换（自动类型转换）：取值范围小的类型转为取值范围大的类型
        byte/short/char ->int ->long ->float ->double

        byte b = 20;
        int i = b;

        short s = 30;
        int i2 = b + s;
    显式转换（强制类型转换）：取值范围大的类型转为取值范围小的类型
        小的类型 变量名 = (小的类型)大的类型的数据;
        int i3 = 100;
        byte b2 = (byte)i3;

多态的优缺点
    缺点：
        多态之后（向上转型），不能再调用子类特有的方法

    优点：
        提高了代码的复用性

类型转换异常：ClassCastException

instanceof运算符
    格式：
        对象或者对象名 instanceof 类型名

    作用：
        判断对象是否是指定的类型

    使用
        编译报不报错
            instanceof作用的对象的类型和右边的类型名必须有子父类或者父子类关系，否则编译报错

        运行结果是否为true
            如果编译不报错，结果到底是true还是false，要看运行是否属于指定的类型


今日重点：
    （1）能够定义接口，使用interface
    （2）能够定义接口中的5个内容，并使用
    （3）能够使用接口
        三个步骤：
            编写一个实现类去实现接口
            在实现类中重写抽象方法
            在测试类中创建实现类的对象调用重写方法
    （4）实现多态的三个前提
        有继承或者实现关系
        有方法重写
        有父类引用指向子类对象
    （5）能够使用向上和向下转型
    （6）能够理解ClassCastException异常出现的原因，并解决，使用instanceof运算符
    （7）独立编写案例测试多态和向上向下转型
    （8）独立编写USB案例