idea笔记六（接口、多态）

 1.接口

       （1） 生活中：接口是一种公共的规范标准，只要符合规范标准，大家就可以通用

        （2）代码：接口就是多个类的公共规范

                  接口是一个引用数据类型，最重要的内容就是其中的：抽象方法

       （3） 如何定义一个接口格式：

                public interface 接口名称{

                          //接口内容

                }

                #换成关键字interface之后，编译生成的字节码文件任然是：.java---->.class

        如果是java 7 那么接口中可以包含 内容有：

                ①常量

                ②抽象方法

        如果是java 8那么还可以额外包含有:

                ③默认方法

                ④静态方法

        如果是java 9那么还可以额外包含有：

                ⑤私有方法

        （4）在任何版本的java中，接口都可以定义抽象方法

                      public abstract 返回值类型 方法名称（参数列表）；

                注意事项：

                ①接口当中的抽象方法，修饰符必须是固定的两个关键字：public abstract

                ②这两个关键字修饰符，可以选择性的省略

                ③方法的三要素可以随意定义

        （5）接口使用步骤

                ①接口不能直接使用，必须有一个“实现类”来实现接口

                格式：

                public class 实现类名称 implements 接口名称{

                        //....

                }

                ②接口的实现类必须覆盖重写（实现）接口中的所有抽象方法

                实现：去掉abstract关键字，加上方法体大括号

                ③创建实现类的对象进行使用 

                注意事项：如果实现类并没有覆盖重写接口中所有的抽象方法，那么这个实现类必须是                                   抽象类

        （6）接口的默认方法（从java8开始）

                public default 返回值类型 方法名称(参数列表){

                                  方法体

                }

                备注：接口当中的默认方法，可以解决接口升级问题

        （7）静态方法定义（从java8开始允许定义）

                格式：

                public static 返回值类型 方法名称(参数列表){

                             方法体

                }

                #就是将abstract或者default换成static即可，带上方法体

        （8）静态方法的使用

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

                正确用法：通过接口名称，直接调用其中的静态方法

                        格式：接口名称.静态方法名称(参数)；

        （9）私有方法的定义

                问题：我们需要抽取一个共有方法，用来解决两个默认方法之间重复代码的问题，但是                            这个公共方法不应该让实现类使用，应该是私有化

                解决：从java9开始，接口允许定义私有方法

                        1.普通私有方法：解决多个默认方法之间重复代码的问题

                        格式：

                                private 返回值类型 方法名称(参数列表){

                                                方法体

                                }

                        2.静态私有方法：解决多个静态方法之间重复代码的问题

                        格式：

                                private static 返回值类型 方法名称(参数列表){

                                                方法体

                                }

         （10）接口的常量定义和使用

                接口当中当然也可以定义“成员变量”，但是必须使用public static final三个关键字修饰

                从效果上看，这其实就是接口的【常量】

                格式：

                        public static final 数据类型 常量名称 = 数据值；

                        #一旦使用final关键字进行修饰，说明不可改变

                注意事项

                        ①接口当中的常量，可以省略public static final ，注意：不写也照样是这样

                        ②接口当中的常量，必须进行赋值，不能不赋值

                        ③接口当中的常量，使用完全大写的字母，用下划线进行分割（推荐命名规则）

 

        （11）使用接口的注意事项

                ①接口是没有静态模块和构造方法的

                ②一个类的直接父类是唯一的，但是一个类可以同时实现多个接口

                格式：

                public class MyInterfaceImpl implements MyInterfaceA,MyInterfaceB{

                                 //覆盖重写所有抽象方法

                }

                ③如果实现类的所实现的接口当中，存在重复抽象方法，那么只需要覆盖重写一次即可

                ④如果实现类没有覆盖重写所有接口的所有抽象方法，那么实现类必须是一个抽象类

                ⑤如果实现类所实现的多个接口中，存在重复的默认方法，那么实现类一定要对冲突的                     默认方法进行覆盖重写

                ⑥一个类如果父类当中的方法，和接口当中的默认方法产生冲突，优先使用父类当中的                     方法

        （12）接口直接的多继承

                ①类与类直接是单继承的，直接父类只有一个

                ②类与接口之间是多实现的，一个类可以实现多个接口

                ③接口与接口之间是多继承的

                注意事项：

                ①多个父接口当中的抽象方法如果重复，没关系

                ②多个父接口当中的默认方法如果重复，那么子接口必须进行默认方法的覆盖重写，

                   【而且带着default关键字】

2.多态

​​​​​​​        （1）多态的概述

                面向对象的三大特征：封装性，继承性，多态性

                #extends继承或者implements实现，是多态性的前提

                一个对象拥有多种形态，这就是：对象的多态性

        （2）多态的格式和使用

                代码当中体现多态性：父类引用指向子类对象

                格式：

                        父类名称 对象名 = new 子类名称();

                或者：

                        接口名称 对象名 = new 实现类名称();

        （3）成员变量的使用特点

                访问成员变量的两种方式：

                ①直接通过对象名称访问成员变量：看等号左边是谁，优先用谁，没有则向上找

                ②间接通过成员方法访问成员变量：看该方法属于谁，优先用谁，没有则向上找

        （4）成员方法的使用特点

                在多态的代码中，成员方法的访问规则是：看new的是谁就用谁，没有就向上找

                           口诀：编译看左边，运行看右边

                成员变量：编译看左边，运行还看左边

                成员方法：编译看左边，运行看右边

        （5）多态的好处

         （6）对象的向上转型

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

                格式：父类名称 对象名 = new 子类名称();

                含义：右侧创建一个子类对象，把他当做父类来使用

                注意事项：向上转型一定是安全的，小范围转向大范围

        （7）对象的向下转型

                向上转型弊端：对象一旦向上转型为父类，那么就无法调用子类原本的特有的内容

                                        解决方案：用对象的向下转型【还原】

                格式：子类名称 对象名 = (子类名称)父类对象;

                含义：将父类对象，【还原】成为本来的子类对象

                注意对象：向下转型注意不要转型成同一父类中的子类，

                                 否则会报错（ClassCastException） 

        （8）instanceof关键字

                格式：对象 instanceof 类名称

                这将会得到一个Boolean值结果，也就是判断前面的对象能不能当做后面的类型的实例