接口，

接口

接口的定义

• 接口是多个类的公共规范，就像是一种约定

• 接口是一种引用数据类型，最重要的内容就是其中的抽象方法

• 接口格式：public interface 接口名称 { 接口内容 }

• 接口可包含的内容有：常量、抽象方法、默认方法、静态方法、私有方法

接口使用方法

抽象方法

• 接口不能直接使用，必须有一个实现类来实现该接口

  格式：public class 实现类名称 implements 接口名称

• 接口的实现类必须覆盖重写接口所有的抽象方法

• 创建实现类的对象才可以使用

• 注意：如果实现类没有覆盖重写接口中所有的抽象方法，那么这个实现类就是抽象类（用abstract修饰）

  格式：public abstract 返回值类型 方法名称 (参数列表);

  package character;
  //接口
  public interface AD {
      //定义抽象方法，能够进行物理攻击
      public abstract void physicalAttrack();
  }
  
  ////////////////////////////
  
  package character;
  //实现类
  public class ADHero implements AD {
  
      String name; //姓名
      private float hp;//血量
      private float armor; //护甲
      int moveSpeed; //移动速度
  
      //覆盖重写接口的抽象方法
      @Override
      public void physicalAttrack(){
          System.out.println("进行物理攻击");
      }
  }
  
  //////////////////////////////
  
  package character;
  
  public class ADHeroInterface {
      public static void main(String[] args) {
          //创建实现类的对象
          ADHero hero = new ADHero();
          hero.physicalAttrack();
      }
  }
  

默认方法和静态方法（Java 8）

• 接口中允许使用默认方法，主要用于解决接口升级问题

• 接口的默认方法可以通过实现类直接调用，也可以被实现类覆盖重写

  格式：public default 返回值类型 方法名称 (参数列表) { 方法体 }

• 接口中也可使用静态方法，且不能通过实现类的对象来调用接口中的静态方法，应直接通过接口名称调用静态方法

  格式：public static 返回值类型 方法名称 (参数列表) { 方法体 }

  package character;
  //接口
  public interface AD {
      //定义抽象方法，能够进行物理攻击
      public abstract void physicalAttrack();
  
      //新添加一个方法，应为默认方法，
      //当为抽象方法时，实现类应该重新覆盖重写，否则会报错
      public default void recieve(){
          System.out.println("复活");
      }
      
      //定义静态方法
      public static void methodStatic(){
          System.out.println("这是静态方法");
      }
  }
  
  ///////////////////////////////
  
  package character;
  //实现类
  public class ADHero implements AD {
      String name; //姓名
      private float hp;//血量
      private float armor; //护甲
      int moveSpeed; //移动速度
  
      //覆盖重写接口的抽象方法
      @Override
      public void physicalAttrack(){
          System.out.println("进行物理攻击");
      }
  
  //    //可以覆盖重写默认方法
  //    @Override
  //    public void recieve() {
  //        System.out.println("覆盖重写默认方法");
  //    }
  }
  
  ////////////////////////////////
  
  package character;
  
  public class ADHeroInterface {
      public static void main(String[] args) {
          //创建实现类的对象
          ADHero hero = new ADHero();
          hero.physicalAttrack();
          hero.recieve();//可直接调用默认方法
  		AD.methodStatic();//直接通过接口调用静态方法
      }
  }
  

私有方法（Java 9）

• 可用私有方法解决接口中方法的重复代码问题

• 普通私有方法解决多个默认方法之间重复代码的问题

  格式：private 返回值类型 方法名称 (参数列表) { 方法体 }

• 静态私有方法解决多个静态方法之间重复代码的问题

  格式：private static 返回值类型 方法名称 (参数列表) { 方法体 }

  //接口
  public interface AD {
  
      //定义抽象方法，能够进行物理攻击
      public abstract void physicalAttrack();
  
      //新添加一个方法，应为默认方法，
      // 当为抽象方法时，实现类应该重新覆盖重写，否则会报错
      public default void recieve(int hp){
          System.out.println("复活");
          methodCommonRecieve(hp);
      }
  
      //定义静态方法
      public static void methodStatic(){
          System.out.println("这是静态方法");
          methodCommonStatic();
      }
  
      //普通私有方法
      private void methodCommonRecieve(int hp){
          System.out.println("加血：" + hp);
      }
  
      //静态私有方法
      private static void methodCommonStatic(){
          System.out.println("AAAAA");
      }
  }
  

接口常量

• 接口中的常量需用 public static final三个关键字修饰

  例如：public static final int NUM_OF_HP = 10;

• 接口中的常量必须进行赋值

• 接口常量的名称使用完全大写的字母，用下划线分隔

继承多个接口

• 接口无静态代码块或者构造方法

• 一个类的直接父类是唯一的，但是一个类可以同时实现多个接口

  格式：public class 实现类名称 implements 接口1, 接口2

  • 如果实现类所实现的多个接口中存在重复的抽象方法，只需要覆盖重写一次

  • 如果实现类所实现的多个接口中存在重复的默认方法，那么实现类一定要对冲突的默认方法覆盖重写

• 注意：如果一个类的直接父类的方法和接口中的默认方法产生冲突，优先调用父类中的方法，即继承优先于接口

• 一个接口可以继承多个接口

  格式：public interface 接口3 extends 接口1, 接口2

  • 如果多个父接口中存在重复的抽象方法，没关系
  • 如果多个父接口中存在重复的默认方法，那么子接口必须对默认方法覆盖重写

  package character2;
  
  public interface AD {
  
      public abstract void attrack();
      public default void method(){
          System.out.println("这是物理攻击英雄");
      }
  }
  
  ////////////////////////////////
  
  package character2;
  
  public interface AP {
      
      public abstract void attrack();
      public default void method(){
          System.out.println("这是魔法攻击英雄");
      }
  }
  
  /////////////////////////////////
  
  package character2;
  
  public interface ADAPHero extends AD, AP {
  
      //重复的抽象方法不需要覆盖重写
      //重复的默认方法需要在子接口覆盖重写
      @Override
      default void method() {
          System.out.println("这是进行物理攻击和魔法攻击的英雄");
      }
  }
  
  /////////////////////////////////
  
  package character2;
  
  public class Hero implements ADAPHero {
  
      //重复的抽象方法在实现类需要覆盖重写
      @Override
      public void attrack() {
          System.out.println("抽象方法，物理魔法攻击");
      }
  
      public static void main(String[] args) {
          Hero hero = new Hero();
          hero.attrack();
          hero.method();
      }
  }