随着JDK版本的更新，各种新增的知识点越来越多了，今天我们就来介绍一下我们非常熟悉的接口。来看看接口在JDK9之后添加了哪些新的东西？
一、JDK9以前的接口
以前的接口很简单，定义和使用格式如下：
JDK9之前，接口中没有构造方法，成员方法只能是常量，成员方法只能是抽象方法，抽象方法不能与 private，
static，final共存。
private：因为私有的方法不能被其他类使用，而抽象方法一定要被实现类实现。
static：静态方法可以接口名点方法名调用，而抽象方法没有方法体，调用没有意义。
final：最终方法不能被重写，而抽象方法一定要被实现类实现。
二、接口中的默认方法
public interface 接口名{//定义
.....
}
public class Inter implements 接口名{//使用
实现接口中所有的抽象方法
}
public interface MyInterfaceDefault {
// 抽象方法
public abstract void methodAbs();
// 新添加的方法，改成默认方法
public default void methodDefault() {
System.out.println("这是新添加的默认方法");
}
}
public class MyInterfaceDefaultA implements MyInterfaceDefault {
@Override
public void methodAbs() {
System.out.println("实现了抽象方法，AAA");
}
}
public class MyInterfaceDefaultB implements MyInterfaceDefault {
@Override
public void methodAbs() {
System.out.println("实现了抽象方法，BBB");
}
接口中的默认方法是为了解决接口的升级导致的实现类报错的问题。
三、接口中的静态方法
接口中的默认方法是为了解决接口的升级导致的实现类报错的问题。
那么问题来了？什么是接口的升级呢？
比如：
@Override
public void methodDefault() {
System.out.println("实现类B覆盖重写了接口的默认方法");
}
}
//测试类
public static void main(String[] args) {
// 创建了实现类对象
MyInterfaceDefaultA a = new MyInterfaceDefaultA();
a.methodAbs(); // 调用抽象方法，实际运行的是右侧实现类。
// 调用默认方法，如果实现类当中没有，会向上找接口
a.methodDefault(); // 这是新添加的默认方法
System.out.println("==========");
MyInterfaceDefaultB b = new MyInterfaceDefaultB();
b.methodAbs();
b.methodDefault(); // 实现类B覆盖重写了接口的默认方法
}
public interface MyInterfaceStatic {
public static void methodStatic() {
System.out.println("这是接口的静态方法！");
}
}
public class MyInterfaceStaticImpl implements MyInterfaceStatic {
}
public static void main(String[] args) {
// 创建了实现类对象
MyInterfaceStaticImpl impl = new MyInterfaceStaticImpl();
// 错误写法！
//impl.methodStatic();
// 直接通过接口名称调用静态方法
MyInterfaceStatic.methodStatic();
}
上面的代码语法是没有的。我已经将这个实现体系全部写好，现在也已经投入正常的项目运行了。此时，项目经理
说： 我要在接口中多加一个抽象方法。 public abstract void bbb();那么下面所有的实现类都报错了。
可想而知，如果我们Java在JDBC中添加了一个抽象方法，那么所有的数据库生成厂商都要跟着改，且低版本的就不
能使用了，这个对于我们程序的向下兼容就不是很友好了。
四，接口的私有方法
interface AAA{ //但是如果你是接口，那么你是不知道被哪些类实现的。
public abstract void aaa();
public abstract void bbb();
} c
lass Aimpl implements AAA{ //实现类。知道自己实现了哪个接口
public void aaa(){
System.out.println("Aimpl");
}
} c
lass Bimpl implements AAA{
public void aaa(){
System.out.println("Bimpl");
}
} c
lass Cimpl implements AAA{
public void aaa(){
System.out.println("Cimpl");
}
} c
lass Dimpl implements AAA{
public void aaa(){
System.out.println("Dimpl");
}
}
public interface MyInterfacePrivateA {
public default void methodDefault1() {
System.out.println("默认方法1");
methodCommon();
} p
ublic default void methodDefault2() {
System.out.println("默认方法2");
methodCommon();
} p
rivate void methodCommon() {
System.out.println("AAA");
System.out.println("BBB");
System.out.println("CCC");
其实私有方法很好理解，就是为了解决默认方法和静态方法中代码重复问题，而这些代码又是在接口中提出的，所
以实现类调用是没有意义的，所以就要私有化。
System.out.println("CCC");
}
}
public interface MyInterfacePrivateB {
public static void methodStatic1() {
System.out.println("静态方法1");
methodStaticCommon();
}
public static void methodStatic2() {
System.out.println("静态方法2");
methodStaticCommon();
}
private static void methodStaticCommon() {
System.out.println("AAA");
System.out.println("BBB");
System.out.println("CCC");
}
}
public class MyInterfacePrivateAImpl implements MyInterfacePrivateA {
public void methodAnother() {
// 直接访问到了接口中的默认方法，这样是错误的！
// methodCommon();
}
}