接口interface

接口的定义与特点：

接口用关键字interface来定义

public interface 接口名{
    //常量
    //抽象方法
 public static final int age=18;
    public static final String name="长江三号";

    public abstract void run();

}

 实现l类：实现接口的类（可以理解为子类）

修饰符 class 实现类 implements 接口1,接口2，...{


}

 接口与接口的关系:多继承。

类和类的关系：单继承。

类和接口的关系：多实现。

 JDK8后新增的几项方法:

public interface SportMan  {
    /*
    1,默认方法
    ————必须default修饰，默认由public修饰
    用对象调
     */
    default void run(){
        System.out.println("默认方法");
        go();
    }
    /*
        静态方法
        用接口名去调
     */
    public static void inAddr(){
        System.out.println("静态方法");
    }
    /*
    私有方法
    只能在接口内部才能被访问
     */
    private void go(){
        System.out.println("开始跑");
    }
}
class  PingPongMan implements SportMan{

}
class Test{
    public static void main(String[] args) {
        PingPongMan p=new PingPongMan();
        p.run();

        SportMan.inAddr();
    }
}

接口不能创建对象（接口更加抽象）

一个类实现多个接口多个接口中有同样的静态方法不冲突

public class Test_01 implements A,B{
    public static void main(String[] args) {

    }
}
interface A{
    static void go(){
        System.out.println("AAA");
    }
}
interface B{
    static void go(){
        System.out.println("BBB");
    }
}

一个类继承了父类，同时又实现了接口，父类中和接口有同名方法的默认使用父类的

public class Test_01 implements A{
    public static void main(String[] args) {
        Zi z=new Zi();
        z.go();
    }
}
interface A{
    default void go(){
        System.out.println("AAA");
    }
}
class Fu{
   public  void go(){
        System.out.println("父类");
    }
}
class Zi extends Fu implements A  {
    
}
//程序运行结果：父类

一个类实现了多个接口，多个接口中存在同名的默认方法不冲突，在这个类重写该方法即可

public class Test_01 {
    public static void main(String[] args) {
        C c=new C();
        c.go();
    }
}
interface A {

    default void go() {
        System.out.println("AAA");
    }
}
interface B {
    default void go() {
        System.out.println("父类");
    }
}
class C implements A,B{
    @Override
    public void go() {
        A.super.go();
        B.super.go();
    }
}

一个接口可以继承多个接口，如果多个接口中存在规则冲突则不能多继承