接口声明时，如果关键字interface前面加上public->public接口，可以被任何一个类使用
如果一个接口不加public修饰->友好接口类，可以被同一个包中的类使用
java7接口中可以包含
1、常量
2、抽象方法
java8接口中额外包含：
3、默认方法
4、静态方法
java9接口额外包含：
5、私有方法
接口抽象方法：
注意：
1、接口当中的抽象方法，修饰符必须是两个固定的关键字，public abstract
2、这两个关键字修饰符，可以选择性地省略
使用：
1、接口不能直接使用。必须有一个实现类来实现接口
格式：
public class 类名称 implements 接口名称{//..
}
2、接口的实现类必须覆盖重写接口中所以的抽象方法
重写接口中的方法，访问权限一定时public
3、创建实现类的对象，进行调用
public interface MyInterface {
public abstract void method();
void method1();
}
public class a implements MyInterface{
@Override
public void method() {
System.out.println("这是第一个方法");
}
@Override
public void method1() {
System.out.println("这个是第二个方法");
}
}
public class b {
public static void main(String[] args) {
a aa=new a();
aa.method();
aa.method1();
}
}如果实现类并没有覆盖重写接口中所有的抽象方法，那么这个实现类自己必须是一个抽象类
接口的默认方法：
格式：
public default 返回值类型 方法名称（参数列表）{方法体
}
public可以省略
接口中的默认方法
1、可以解决 接口升级的问题
2、可以和函数式编程结合
如果一个接口有已经定义许多个子类，但是如果在接口中又新增了一个方法（这个方法如果不另加说明为抽象方法），为了让子类都覆盖了抽象方法，就不得不在每一个子类中都覆盖这个新加 的抽象方法，但是这样又会很麻烦。
所以可以把新添加的方法改为默认方法
public interface MyInterface {
void method();
public default void method1(){
System.out.println("新添加的方法");
}
}
public class a implements MyInterface {
@Override
public void method() {
}
}
public class b {
public static void main(String[] args) {
a aa=new a();
aa.method();
aa.method1();
}
}接口的默认方法会被子类继承，可以由子类调用
这样就可以不用全部都重新覆盖，但子类仍然可以调用新添加的方法
注意：接口的默认方法也可以被子类覆盖重写
接口的静态方法：
public static 返回值 方法名称（参数名称）{
方法体
}
public可以省略
不能通过接口实现类的对象来调用接口当中的静态方法
通过接口名称，直接调用其中的静态方法:
接口名称.静态方法名（参数）
public interface MyInterface {
public static void method1(){
System.out.println("调用静态方法");
}
}
public class b {
public static void main(String[] args) {
MyInterface.method1();
}
}接口的私有方法：
如果需要抽取一个共有方法，用来解决两个默认方法之间重复代码的问题。
但是这个共有方法不应该让实现类使用，应该是私有化的。
所以，应该把这个共有方法实设为私有的
1、普通私有方法，解决多个默认方法之间重复代码问题：
private 返回值类型 方法名称（参数列表）{
方法体}
2、静态私有方法，解决多个静态方法之间重复代码问题：
格式：
private static 返回值 方法名称（参数列表）{
方法体}
public interface MyInterface {
public default void method1(){
method();
}
public default void method2(){
method();
}
private void method(){
System.out.println("111");
}
}
public class a implements MyInterface {
}
public class b {
public static void main(String[] args) {
a aa=new a();
aa.method1();
aa.method2();
}
}public interface MyInterface {
public static void method1(){
method();
}
public static void method2(){
method();
}
private static void method(){
System.out.println("111");
}
}
public class a implements MyInterface {
}
public class b {
public static void main(String[] args) {
MyInterface.method1();
MyInterface.method2();
}
}接口的常量
接口当中也可以定义”成员变量“，但是必须使用public static final 三个关键字进行修饰
从效果上看，其实是接口的【常量】
public static final 数据类型 常量名称=数据值；
注意：
（1）一旦使用final关键字进行修饰，说明不可改变
（2）接口中的常量，可以省略【public】 【static】 【final】 ，注意，不写照样也是这样
（3）接口中的常量，必须进行赋值，不能不赋值
（4）常量的命名为大写，且用下划线分割
常量的使用：
public interface MyInterface {
public static final int NUM=10;
}
public class b {
public static void main(String[] args) {
System.out.println(MyInterface.NUM);
}
}使用接口时候，需要注意：、
1、接口是没有静态代码块或者构造方法的
2、一个类的直接父类是唯一的，但是一个类可以同时实现多个接口
public class MyInterface implements MyInterfaceA,MyInterfaceB{
//覆盖重写所有抽象方法
}接口也是可以被继承的，可以通过关键字extends声明一个接口是另一个接口的子接口，（public）子接口将继承父接口中全部方法和常量
接口与接口之间是多继承的
Public interface MyInterface extends MyInterfaceA,MyinterfaceB{
}(1)多个父接口当中的抽象方法如果重复没有关系
（2)多个父接口当中的默认方法如果重复，那么子接口必须进行默认方法的覆盖重写【带default关键字】
（3）父类实现了某个接口，那么子类就自然实现了该接口，子类不必再显示地使用关键字Implements声明
3、如果实现类所实现的多个接口中，存在重复的抽象方法，那么只需要覆盖重写一次
4、如果实现类没有覆盖重写所有接口当中的所有抽象方法，那么实现类就必须是一个抽象类
5、如果实现类所实现的多个接口当中，存在重复的默认方法，那么类一定要对冲突的默认方法进行覆盖重写
6、一个类如果直接父类当中的方法和接口当中默认方法产生了冲突，优先用父类当中的方法
