基础介绍

接口用来描述类应该做什么，而不是指定它们具体应该怎么做。
在java中，接口不是类，而是对希望符合这个接口的类的一组需求。java只能继承一个类，但是可以实现多个接口。

接口的定义

接口的定义如下

interface sports {

}

接口定义其实就是和类定义相似的。只不过把class换成了interface

我们在interface可以定义方法，就像抽象类那样定义未实现的方法即可。类实现接口时就必须重写方法或者自己成为抽象类

interface Sports {

    void run();
}

在接口里面可以定义方法的默认实现，使用default关键字，如果类实现接口时没有重写该方法，那么该方法就会使用默认实现

interface Sports {

    void run();
    
    default void jump(){
        
    }
}

现在，我们可以暂时将接口看做为没有实例字段的抽象类。

关于接口字段和方法的说明

在接口中，我们不能定义实例字段，但是可以定义静态字段。

interface A {
    public static final int a = 1;
}

但是上面这样写IDEA会有提示

表示字段冗余，其实，在接口中我们定义的字段只能使用public static final进行修饰

我们在接口中可以定义静态方法

interface A {
    public static void t() {

    }
}

对于接口里面的内容，其实我们public修饰符可以不用写，因为接口里面字段和方法的访问修饰符只能是public。

使用接口

我们先定义一个接口，内容如下

interface Sports {
    void run();
}

我们创建一个类来实现接口

class Cat implements Sports {

    @Override
    public void run() {
        System.out.println("cat--run");
    }
}

这个其实和继承基本类似的，只是将关键字从extends换成了implements

关于接口，我们不能够使用new来实例化一个接口

       Sports sports = new Sports(); // ERROR

但是可以声明接口变量，然后引用实现了这个接口的类对象即可

        Sports cat = new Cat(); // OK

对于接口，我们将其看作实现接口类的父类就很好理解了

抽象类和接口

对于一个类，我们只能继承一个类，但是可以实现多个接口。我们就可以将接口看做没有实例字段，并且可以被多继承的抽象类

interface A {

}

interface B {

}

class C implements A, B {
    
}

接口方法冲突的一些说明

方法相同名称和参数，返回值相同

我们知道，一个类可以实现多个接口，如果接口有相同的方法名称和参数会怎么样呢？如果有相同的名称和参数，并且返回值相同，那么我们只需要实现一个t方法即可

interface A {
    void t1();
}

interface B {
    void t1();
}

class C implements A, B {

    @Override
    public void t1() {

    }
}

方法名称相同，参数不同，返回值相同

如果方法只有参数不同，那么我们需要实现2个方法，也就是会进行重载

interface A {
    void t1();
}

interface B {
    void t1(int a);
}

class C implements A, B {
    @Override
    public void t1() {
    }

    @Override
    public void t1(int a) {
    }
}

方法返回值不同，名称参数相同

如果方法名称相同，参数相同，而返回值不同，那么就会报错，我们无法同时实现2个名称相同，参数也相同但是返回值不同的方法。

interface A {
    int t1();
}

interface B {
    void t1();
}

一个类无法同时实现A接口和B接口

方法完全相同，一个有默认实现

如果2个接口一个有默认实现，一个没有默认实现，对于这种情况，我们也必须实现该方法

interface A {
    default void t1() {
    }
}

interface B {
    void t1();
}

class C implements A, B {

    @Override
    public void t1() {
        A.super.t1();
    }
}

但是我们可以通过 接口名.super.方法名调用默认实现的方法

接口和类中方法冲突

对于接口和类冲突的，都以类为准，也就是类优先原则，不管接口是否有默认实现都会被超类中的方法覆盖

interface A {
    default void t1() {
        System.out.println("interface");
    }
}

interface B {
    void t1();
}

class C {
    public void t1() {
        System.out.println("class");
    }
}

class D extends C implements A, B {

}

我们使用D来调用t1方法将会输出class

        D d = new D();
        d.t1();  // 输出class

总结

对于接口，我们将其看作可以被多继承的，并且不能有实例字段的抽象类就行了。对于接口和接口发生冲突时，只要返回类型相同我们就可以处理，如果返回类型不同那就不能同时实现有冲突的接口了。如果接口和超类发生冲突，那么就是以类优先原则来进行解决的。