目录

一、抽象方法

二、接口

一、抽象方法

抽象方法：就是加上abstract关键字，然后去掉大括号，直接分号结束。

抽象类：抽象方法所在的类，必须是抽象类才行。在class之前写上abstract即可。

如何使用抽象类和抽象方法：                                                                                                                         1.不能直接创建new抽象类对象。                                                                                                                 2.必须用一个子类来继承抽象父类。                                                                                                             3.子类必须覆盖重写抽象父类当中所有的抽象方法。                                                                                 重写：子类去掉抽象方法的abstract关键字，然后补上方法体大括号。                                                  4.创建子类对象进行使用。

注意事项：                                                                                                                                                         1.抽象类不能创建对象，如果创建，编译无法通过而报错。只能创建其非抽象子类的对象。             2.抽象类中，可以有构造方法，是供子类创建对象时，初始化父类成员使用的。                                 3.抽象类中，不一定包含抽象方法，但是有抽象方法的类必定是抽象类。                                             4.抽象类的子类，必须重写抽象父类中所有的抽象方法，否则，编译无法通过而报错，除非该子类也是抽象类。

二、接口

接口就是多个类的公共规范。

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

格式：

public interface 接口名称{
    // 接口内容
}

接口中包含的内容有：1.常量  2.抽象方法  3.默认方法  4.静态方法  5.私有方法

在任何版本的Java中，接口都能定义抽象方法。

格式：public abstract 返回值类型 方法名称(参数列表);

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

接口使用步骤：                                                                                                                                                 1.接口不能直接使用，必须有一个“实现类”来“实现”该接口。                                                                格式：                                                         

public class 实现类名称 implements 接口名称{
    // ...
}

2.接口的实现类必须覆盖重写（实现）接口中所有的抽象方法。                                                          实现方法：去掉abstract关键字，加上方法体大括号。                                                                             

3.创建实现类的对象，进行使用。 

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

从Java8开始，接口中允许定义默认方法。                                                                                                  格式：

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

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

接口的默认方法，可以通过实现类对象，直接调用。也可以被接口实现类进行覆盖重写。

从Java8开始，接口中允许定义静态方法。                                                                                                  格式：

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

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

正确用法：通过接口名称，直接调用其中的静态方法。                                                                             接口名称.静态方法名(参数);

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

解决方法：                                                                                                                                                         从Java 9开始，接口中允许定义私有方法。

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

格式：

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

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

格式：

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

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

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

格式：

private static final 数据类型 常量名称 = 数据值;

备注：一旦使用final关键字进行修饰，说明不可改变。

注意事项：                                                                                                                                                        1.接口中的常量，可以省略public static final。                                                                                            2.接口中的常量，必须进行赋值。                                                                                                                3.接口中常量的名称，使用完全大写的字母，用下划线进行分隔。     

使用接口时，需要注意：                                                                                                                                1.接口是没有静态代码块或者构造方法的。                                                                                                  2.一个类的直接父类是唯一的，但是一个类可以同时实现多个接口。

格式：

private class MyInterfaceImpl implements MyInterfaceA, MyInterfaceB{
    //重写所有抽象方法
}
   

3.如果实现类所实现的多个接口中，存在重复的抽象方法，那么只需要重写一次即可。                      4.如果实现类没有重写所有接口中的所有抽象方法，那么实现类必须是一个抽象类。                          5.如果实现类所实现的多个接口中，存在重复的默认方法，那么实现类一定要对冲突的默认方法进行重写。                                                                                                                                                             6.一个类如果直接父类中的方法和接口中的默认方法产生了冲突，优先用父类中的方法。

1.类与类之间是单继承的。直接父类只有一个。                                                                                          2.类与接口之间是多实现的。一个类可以实现多个接口。                                                                          3.接口与接口之间是多继承的。

注意事项：                                                                                                                                                      1.多个父接口中的抽象方法如果重复，没关系。                                                                                          2.多个父接口中的默认方法如果重复，那么子接口必须进行默认方法的重写，【而且带着default关键字】。