接口

        接口就是多个类的公共规范。
        接口是一种引用数据类型，最重要的内容就是其中的：抽象方法。

        定义一个接口的格式：
                public interface 接口名称 {
                        // 接口内容
                }
                备注，换成interface关键字之后，编译生成的字节码文件任然是： .java --> .class

        如果是java 7 ，那么接口中可以包含的内容有：
                1.常量
                2.抽象方法
        如果是java 8 ，那么接口中还可以额外包含有：
                3.默认方法
                4.静态方法
        如果是java 9 ，那么家口中还可以额外包含有：
                5.私有方法
       


        在任何版本的Java中，接口都能定义抽象方法。
        格式：
                public abstract 返回值类型 方法名称(参数列表);

        注意事项：
                1.接口当中的抽象方法，修饰符必须是两个固定的关键字： public abstract
                2.这两个关键字修饰符，可以选择性的省略。(两个都省略或者任意省略都可以)
                3.方法的三要素可以随意定义。

        接口使用步骤：
                1.接口不能直接使用，必须有一个“实现类”来“实现”该接口。
                  格式：
                        public class 实现类名称 implement 接口名称{
                                //方法体
                        }
                2.接口的实现类必须覆盖重写（实现）接口中所有的抽象方法。
                        实现：去掉abstract关键字，加上方法体大括号。

                3.创建实现类的对象，进行使用。
                注意事项：如果实现类并没有覆盖重写接口中所有的抽象方法，那么这个实现类自己就必须是抽象类。


                默认方法：
                        格式：public default 返回值类型 方法名称(参数列表){
                                方法体
                              }
                        1.接口的默认方法，可以通过接口实现类对象，直接调用。
                        2.接口的默认方法，也可以被接口实现类进行覆盖重写。

                       
                静态方法：
                        格式：public static 返回值类型 方法名称(参数列表){
                                方法体
                              }
                        提示：就是讲abstract或者default换成是static即可，带上方法体。

                        注意事项：不能通过接口实现类的对象来调用接口当中的静态方法。
                        正确格式：接口名称.静态方法名(参数);

                       
                私有方法：
                        1.普通私有方法：
                                格式：private 返回值类型 方法名(参数列表){ 方法体 }
                                解决多个默认方法之间重复代码问题

                        2.静态私有方法：
                                格式：private static 返回值类型 方法名(参数列表) { 方法体 }
                                解决多个静态方法之间重复代码问题


                接口中定义常量：
                        格式： public static final 数据类型 常量名称 = 数据值；       
                        备注：一旦使用final关键字进行修饰，说明不可改变,定义的常量必须赋值。
                        注意事项：
                                1.接口当中的常量，可以省略public static final
                                2.接口当中的常量，必须进行赋值，不能不赋值
                                3.接口中常量的名称，使用完全大写的字母，用下划线进行分隔。




内容小结：

1.成员变量其实是常量，格式：
【public static final】 数据类型 常量名称 = 数据值；
注意：
        常量必须进行赋值，而且一旦赋值就不能再改变
        常量名称完全大写，用下划线进行分隔


2.接口中最重要的就是抽象方法，格式：
【public abstract】 返回值类型 方法名称(参数列表)；
注意：
        实现类必须覆盖重写接口中所有的抽象方法，除非实现类是抽象类


3.从Java 8开始，接口里允许定义默认方式，格式：
【public】 default 返回值类型 方法名称(参数列表）{ 方法体 }
注意：
        默认方法也可以被覆盖重写


4.从Java 8开始，接口里允许定义静态方法，格式：
public static 返回值类型 方法名称(参数列表）{ 方法体 }
注意：
        应该通过接口名称进行调用，不能通过实现类对象调用接口静态方法


5.从Java 9开始，接口里允许定义私有方法，格式：
普通私有方法： private 返回值类型 方法名称(参数列表) { 方法体 }
静态私有方法： private static 返回值类型 方法名称(参数列表) { 方法体 }
注意：
        private的方法只有接口自己才能调用，不能被实现类或别人使用。








多态：

        体现多态性：
                其实就是一句话：父类引用指向子类对象

                格式：  父类名称 对象名 = new 子类名称();
                        接口名称 对象名 = new 实现类名称();

        多态的转型：

                1.对象的向上转型，其实就是多态写法：

                        格式： 父类名称 对象名 = new 子类名称；

                        含义： 右侧创建一个子类对象，把它当做父类来看待使用
                       
                        例子：Animal animal = new Cat(); // 创建一只猫，当做动物看待，没问题。
                       
                        注意事项：向上转型一定是成功的。从小范围转向了大范围，从小范围的猫，向上转换成为更大范围的动物。

                        类似于： double num = 100; // 正确  int 自动转为 double


                2.对象的向下转型，其实是一个还原的动作

                        格式： 子类名称 对象名 = (子类名称) 父类对象；
                       
                        含义： 将父类对象还原成为原来的子类对象

                        例子： Animal animal = new Cat;  // 本来是猫，向上转型成为动物
                                Cat cat = (Cat) animal;  // 本来是猫，已经被当做动物了，还原回来成为本来的猫

                        注意事项：
                                a.必须保证对象本来创建的时候，就是猫，才能向下转型成为猫。
                                b.如果对象创建的时候本来不是猫，现在非要向下转型成为猫，就会报错。

                        判断本来是什么子类？
                                格式：
                                        对象 instanceof 类名称
                                        将会得到一个boolean值结果，也就是判断前面的对象能不能当做后面类型的实例。

接口

        接口就是多个类的公共规范。
        接口是一种引用数据类型，最重要的内容就是其中的：抽象方法。

        定义一个接口的格式：
                public interface 接口名称 {
                        // 接口内容
                }
                备注，换成interface关键字之后，编译生成的字节码文件任然是： .java --> .class

        如果是java 7 ，那么接口中可以包含的内容有：
                1.常量
                2.抽象方法
        如果是java 8 ，那么接口中还可以额外包含有：
                3.默认方法
                4.静态方法
        如果是java 9 ，那么家口中还可以额外包含有：
                5.私有方法
       


        在任何版本的Java中，接口都能定义抽象方法。
        格式：
                public abstract 返回值类型 方法名称(参数列表);

        注意事项：
                1.接口当中的抽象方法，修饰符必须是两个固定的关键字： public abstract
                2.这两个关键字修饰符，可以选择性的省略。(两个都省略或者任意省略都可以)
                3.方法的三要素可以随意定义。

        接口使用步骤：
                1.接口不能直接使用，必须有一个“实现类”来“实现”该接口。
                  格式：
                        public class 实现类名称 implement 接口名称{
                                //方法体
                        }
                2.接口的实现类必须覆盖重写（实现）接口中所有的抽象方法。
                        实现：去掉abstract关键字，加上方法体大括号。

                3.创建实现类的对象，进行使用。
                注意事项：如果实现类并没有覆盖重写接口中所有的抽象方法，那么这个实现类自己就必须是抽象类。


                默认方法：
                        格式：public default 返回值类型 方法名称(参数列表){
                                方法体
                              }
                        1.接口的默认方法，可以通过接口实现类对象，直接调用。
                        2.接口的默认方法，也可以被接口实现类进行覆盖重写。

                       
                静态方法：
                        格式：public static 返回值类型 方法名称(参数列表){
                                方法体
                              }
                        提示：就是讲abstract或者default换成是static即可，带上方法体。

                        注意事项：不能通过接口实现类的对象来调用接口当中的静态方法。
                        正确格式：接口名称.静态方法名(参数);

                       
                私有方法：
                        1.普通私有方法：
                                格式：private 返回值类型 方法名(参数列表){ 方法体 }
                                解决多个默认方法之间重复代码问题

                        2.静态私有方法：
                                格式：private static 返回值类型 方法名(参数列表) { 方法体 }
                                解决多个静态方法之间重复代码问题


                接口中定义常量：
                        格式： public static final 数据类型 常量名称 = 数据值；       
                        备注：一旦使用final关键字进行修饰，说明不可改变,定义的常量必须赋值。
                        注意事项：
                                1.接口当中的常量，可以省略public static final
                                2.接口当中的常量，必须进行赋值，不能不赋值
                                3.接口中常量的名称，使用完全大写的字母，用下划线进行分隔。




内容小结：

1.成员变量其实是常量，格式：
【public static final】 数据类型 常量名称 = 数据值；
注意：
        常量必须进行赋值，而且一旦赋值就不能再改变
        常量名称完全大写，用下划线进行分隔


2.接口中最重要的就是抽象方法，格式：
【public abstract】 返回值类型 方法名称(参数列表)；
注意：
        实现类必须覆盖重写接口中所有的抽象方法，除非实现类是抽象类


3.从Java 8开始，接口里允许定义默认方式，格式：
【public】 default 返回值类型 方法名称(参数列表）{ 方法体 }
注意：
        默认方法也可以被覆盖重写


4.从Java 8开始，接口里允许定义静态方法，格式：
public static 返回值类型 方法名称(参数列表）{ 方法体 }
注意：
        应该通过接口名称进行调用，不能通过实现类对象调用接口静态方法


5.从Java 9开始，接口里允许定义私有方法，格式：
普通私有方法： private 返回值类型 方法名称(参数列表) { 方法体 }
静态私有方法： private static 返回值类型 方法名称(参数列表) { 方法体 }
注意：
        private的方法只有接口自己才能调用，不能被实现类或别人使用。








多态：

        体现多态性：
                其实就是一句话：父类引用指向子类对象

                格式：  父类名称 对象名 = new 子类名称();
                        接口名称 对象名 = new 实现类名称();

        多态的转型：

                1.对象的向上转型，其实就是多态写法：

                        格式： 父类名称 对象名 = new 子类名称；

                        含义： 右侧创建一个子类对象，把它当做父类来看待使用
                       
                        例子：Animal animal = new Cat(); // 创建一只猫，当做动物看待，没问题。
                       
                        注意事项：向上转型一定是成功的。从小范围转向了大范围，从小范围的猫，向上转换成为更大范围的动物。

                        类似于： double num = 100; // 正确  int 自动转为 double


                2.对象的向下转型，其实是一个还原的动作

                        格式： 子类名称 对象名 = (子类名称) 父类对象；
                       
                        含义： 将父类对象还原成为原来的子类对象

                        例子： Animal animal = new Cat;  // 本来是猫，向上转型成为动物
                                Cat cat = (Cat) animal;  // 本来是猫，已经被当做动物了，还原回来成为本来的猫

                        注意事项：
                                a.必须保证对象本来创建的时候，就是猫，才能向下转型成为猫。
                                b.如果对象创建的时候本来不是猫，现在非要向下转型成为猫，就会报错。

                        判断本来是什么子类？
                                格式：
                                        对象 instanceof 类名称
                                        将会得到一个boolean值结果，也就是判断前面的对象能不能当做后面类型的实例。