一个例子来让我们理解更加深刻

这是我们的整体文件布局

①A是接口

②B和C是用来实现接口的类

③show是我们的运行函数，用来展示

---

A接口

接口中定义的方法可以不用去实现,用其他类去实现(必须实现)  

关键字:interface 

public interface A {
//    public static final String str = "我是A接口";  可简写为下面 理解为一个常量
    String str = "我是A接口";
//    public abstract void doa(); 可简写为下面
    void doa();
}

B类(用来实现A接口)

关键字:implements 

public class B implements A{
    @Override
    public void doa() {
        System.out.println("我是B类");
    }
}

C类(用来实现A接口)

关键字:implements 

public class C implements A{
    @Override
    public void doa() {
        System.out.println("我是C类");
    }
}

---

定义完成后我们用我们的show来展示一些

show类

这里我们用了B类来实现我们的接口,因此调用显示为“我是B类”

public class show {
    public static void main(String[] args) {
        A a = new B();
        a.doa();
    }
}

我们把B改成C试试

public class show {
    public static void main(String[] args) {
        A a = new C();
        a.doa();
    }
}

显示的我是C类

所以我们就可以很方便的调用两个不同的方案来实现我们的功能,很方便

扩展

我们还可以在里面定义好函数，不用再去实现类中实现它(!!!注意和之前的区别,之前的不同,之前的是在实现类中必须实现)

     /**
     * 1、默认方法：必须使用default修饰，默认会被public修饰
     * 实例方法：对象的方法，必须使用实现类的对象来访问。
     */
default void test1(){
        System.out.println("===默认方法==");
        test2();
    }

    /**
     * 2、私有方法：必须使用private修饰。
     *   实例方法：对象的方法。
     */
    private void test2(){
        System.out.println("===私有方法==");
    }

    /**
     * 3、静态方法：必须使用static修饰，默认会被public修饰
     */
     static void test3(){
        System.out.println("==静态方法==");
     }

---

接口可以继承多个

interface A{
    void test1();
}
interface B{
    void test2();
}
interface C{}

//比如：D接口继承C、B、A
interface D extends C, B, A{

}

但是实现的时候也必须全部实现

//E类在实现D接口时，必须重写D接口、以及其父类中的所有抽象方法。
class E implements D{
    @Override
    public void test1() {

    }

    @Override
    public void test2() {

    }
}