接口，是Java语言中的一种引用类型，是方法的集合，如果说类的内部封装了成员变量、构造方法和成员方法，那么接口的内部主要就是封装了方法，包括抽象方法（JDK7及以前），默认方法和静态方法（JDK8）。
接口的定义与类相似，使用interface关键字，它会被编译成 .class 文件，但一定要明确它并不是类，而是另外一种引用数据类型（接口，类，数组）。
public class 类名.java -->.class
public interface 接口名.java-->.class
接口的使用，它不能创建对象，但是可以被实现（implements，类似于被继承）。一个实现接口的类（可以看做是接口的子类），需要实现接口中的所有抽象方法，创建该类对象，就可以调用方法了，否则它必须是一个抽象类。
定义格式
public interface 接口名称{
//抽象方法（可选，可以省略）
//默认方法（必选，不可省略）
//静态方法
}含有抽象方法
抽象方法：使用abstract关键字修饰，可以省略，没有方法体，该方法提供子类实现使用。
public interface InterFaceName{
public abstract void method();
}含有默认方法和静态方法
默认方法：使用default修饰，不可省略，供子类调用或者子类重写。
静态方法：使用static修饰，供接口直接调用
public interface InterFaceName{
public default void method(){
//执行语句
}
public static void methods(){
//执行语句
}
}基本实现
类与接口的实现关系即类实现接口，该类可以称为接口的实现类，也可以称为接口的子类，实现的动作类似继承，格式相仿，关键字是inplements
非抽象子类实现接口
- 必须重写接口中所有抽象方法
- 继承了接口的默认方法，即可以直接调用，class 类名 implememnts 接口名{ //重写接口中的抽象方法【必须】 //重写接口中的默认方法【可选】 }
class 类名 implements 接口名{
//重写接口中抽象方法【必选】
//重写接口中的默认方法【可选】
}抽象方法的使用（必须全部实现）
定义接口
public interface LiveAble{
//定义抽象方法
public abstract void eat();
public abstract void singing();
}定义实现类
public class Beauty implements LiveAble{
@Override
public void eat(){
System.out.println("吃播开始“）；
}
@Override
public void singing(){
System.out.println("歌手准备“）；
}
}定义测试类：
public class InterfaceDemo{
public static void main(String[] args){
//创建子类对象
Beauty b = new Beauty();
//调用实现后的方法
b.eat();
b.sleep();
}
}
输出结果：
吃播上线
歌手准备默认方法的使用
可以继承，可以重写，二选一，但是只能通过实现类的对象来调用。
1，继承默认方法，代码如下
定义接口：
public interface LiveAble{
public default void fly(){
System.out.println("超人来了“）；
}
}定义实现类：
public class Beauty implements LiveAble{
//继承，什么都不用写，直接使用
}定义测试类：
public class InterFaceDemo{
public static void main(String[] args){
//创建子类对象
Beauty b = new Beauty();
//调用默认方法
b.fly();
}
}
输出结果：
超人来了重写默认方法：
定义接口
public interface LiveAble{
public default void fly（）{
System.out.println("超人来了“）；
}
}定义实现类
public class Beauty impliemnts LiveAble{
@Override
public void fly(){
System.out.println("自由自然地飞");
}
}定义测试类
public class InterFaceDemo{
public static void main（String[] args）{
//创建类对象
Beauty b = new Beauty();
//调用方法
}
}
输出结果：
自由自在地飞静态方法的使用
静态与 .class 文件相关，只能使用接口名调用，不可以通过实现类的类名或者实现类的对象调用
定义接口
public interface LiveAble{
public static void run(){
System.out.println("paoqilai");
}
}定义实现类：
public class Beauty implements LiveAble{
//无法重写静态方法
}定义测试类：
pbulic class InterFaceDemo{
public static void main(String[] args){
//Beauty.run();//[错误]无法继承方法，也无法调用
LiveAble.run();//
}
}
输出结果：
paoqilai成员变量的使用
接口，无法定义成员变量，但是可以定义常量，其值不可以改变，默认使用public static final 修饰
定义接口：
public interface LiveAble{
int NUM0; // 错误，必须赋值
int NUM1=10; //正确，省去了默认修饰符，public static final
public static final int NUM2 = 100；//正确，完整写法
}定义测试类
public class InterfaceDemo{
public static void main（String[] args){
System.out.println(LiveAble.NUM1);
System.out.println(LiveAble.NUM2);
}
}
输出结果：
10
100接口的多实现
在继承体系中，一个类只能继承一个类，对于接口而言，一个类是可以实现多个接口的，这叫做接口的多实现。所以，一个类能继承一个类，同时实现多个接口。
class 类名 [extends 父类名] implements 接口名1，接口名2，接口名3...{
//重写接口中的抽象方法【必须】
//重写接口中的默认方法【不重名时可选】
}抽象方法
接口中，多个抽象方法是，实现类必须重写所有的抽象方法。如果抽象方法有重名，只需重写一次
默认方法
接口中，有多个默认方法时，实现类都可以继承使用。如果默认方法有重名，必须重写一次
静态方法
接口中，存在同名的静态方法并不会冲突，原因是只能通过各自接口名访问静态方法
接口的多继承
一个接口能继承另外一个或者多个接口，这和类之间的继承比较相似。接口的继承使用extends关键字，子接口继承父类接口的方法。如果父类接口中的默认方法有重名的，那么子接口需要重写一次。
定义父接口：
interface A{
public default void method(){
System.out.println("AAA")};
}
}
interface B{
public default void method(){
System.out.println("BBB");
}
}定义子接口：
interface D extends A,B{
@Override
public default void method（）{
System.out.printl("DDDD");
}
}抽象类和接口对比（小结）
相同点：
都位于继承的顶端，用于被其他类实现或继承；
都不能直接实例化对象
都包含抽象方法，其子类都必须覆写这些抽象方法
区别：
抽象类为部分方法提供实现，避免子类重复实现这些方法，提高代码重复性
接口只能包含抽象方法
一个类只能继承一个直接父类（可能是抽象类），却可以实现多个接口；（接口弥补了Java的单继承）
抽象类为继承体系中的共性内容；
接口为继承体系中的扩展功能；
成员区别：
- 抽象类：变量、常量；有构造方法；有抽象方法，也有非抽象方法
- 接口：常量、抽象方法
关系区别：
- 类与类：继承、单继承
- 类与接口：实现、可以单实现，也可以多实现
- 接口与接口：继承、单继承、多继承
设计理念区别：
- 抽象类：对类抽象，包括属性、行为
- 接口：对行为抽象，主要是行为
