一.接口

• 概念

  接口是Java编程语言中一种引用类型，是方法的集合，接口通常以interface来声明，接口的内部主要就是封装了方法，包含抽象方法，默认方法和静态方法，私有方法。

• 接口的声明

  public interface 接口名称 {
  // 抽象方法
  // 默认方法
  // 静态方法
  // 私有方法
  }

• 接口的定义方法与实现

1. 抽象方法

【使用abstract，子类必须实现,定义接口可省略public与abstract】
继承默认方法：

  接口：
   public interface  名{
    void eat();
    void sleep();
   }
  实现类：
   public class dowu implements 名{
    @Override
    public void eat() {
     System.out.println("吃东西");
    }
    @Override
    public void sleep() {
     System.out.println("晚上睡");
    }
   }
 测试类：
   public class Dom01 {
    public static void main(String[] args) {
      dowu a = new dowu();
      a.eat();
      a.sleep();
    }
   }

2. 默认方法

默认：【使用 default ，继承重写，二选一，只能通过实现类的对象来调用，定义接口可省略public】

  接口：
   public interface 名{
    default void fly(){
     System.out.println("天上飞");
     }
   }
  实现：
   public class dowu implements 名{
    @Override
    public void fly() {
     System.out.println("自由自在的飞");
    }
   }
 重写默认方法：
 接口：
   public interface 名 {
    default void fly(){
     System.out.println("天上飞");
    }
   }
  实现：
   public class dowu implements 名{
    @Override
    public void fly() {
   System.out.println("自由自在的飞");
    }
   }
  **（测试如上）**

3.静态方法

静态：【使用 static，只能接口名调用，接口名.静态方法，定义接口可省略public】

  接口：
   public interface 名{
     static void run(){
     System.out.println("跑起来~~~");
    }
   }
  实现：不可重写
  测试类：
   public class Dom01{
    public static void main(String[] args) {
     //Animal.run(); // 【错误】无法继承方法,也无法调用
      LiveAble.run();

}
}

4. 私有方法和私有静态方法

私有方法：【使用 private ，只能在本地默认方法中调用，不能在静态方法中使用】
私有静态方法：【本地默认方法和静态方法可以调用】

   public interface 名{
    default void func(){
     func1();
     func2();
     func3();
    }
    【如果一个接口中有多个默认方法，并且方法中有重复的 
     内容，那么可以抽取出来，封装到私有方法中，供默认 
     方法 去调用。】
    private void func1(){
     System.out.println("跑起来~~~");
    }
    private void func2(){
     System.out.println("跑起来~~~");
    }
    private static void func3(){
       System.out.println("奥利给~~~");
    }
   }
   

• 接口的多实现

  一个类是可以实现多个接口的，这叫做接口的多实现。并且，一个类能继承一个父类，同时实现多个接口。extends关键字只需要使用一次，在其后跟着实现接口。 如下：
  class 类名 extends 父类名 implements 接口名1,接口名2... {
  // 重写接口中抽象方法【必须】
  // 重写接口中默认方法【不重名时可选】
  }

  1.抽象方法

  必须重写所有抽象方法，有重名，只需重写一次。
  接口：

  interface A {
   public abstract void showA();
   public abstract void show();
   }
   interface B {
   public abstract void showB();
   public abstract void show();
   }

  实现：

   public class C implements A,B{
   @Override
    public void showA() {
     System.out.println("showA");
    }
   @Override
   public void showB() {
     System.out.println("showB");
     }
   @Override
   public void show() {
    System.out.println("show");
    }
  }

  2.默认方法

  如果默认方法有重名的，必须重写。
  接口：

  interface A {
   public default void methodA(){}
   public default void method(){}
  }
  interface B {
   public default void methodB(){}
   public default void method(){}
  }

  实现：

  public class C mplements A,B{
   @Override
   public void method() {
    System.out.println("method");
   }
  }

  3.静态方法

  是只能通过各自接口名访问静态方法。

• 多继承

  类不可以多继承，但接口允许多继承，用extends屁股后面跟着继承接口。
  格式：
  public interface Hockey extends KPL，NBA
  温馨提示
  父接口中的默认方法有重名，子接口需要重写一次哦。