Java学习-9.接口-CSDN博客

本文链接：https://blog.csdn.net/qian013/article/details/51175155

接口

接口和内部类为我们提供了一种将接口与实现分离的更加结构化的方法。

抽象类和抽象方法

包含抽象方法的类叫做抽象类。如果一个类含有一个或多个抽象方法，该类必须被限定为抽象的。

抽象方法的声明所采用的语法：

 abstract void f();

如果从一个抽象类继承，并想创建该新类的对象，那么就必须为基类中的所有抽象方法提供方法定义。

创建抽象类和抽象方法非常有用，因为它可以使类的抽象性明确起来，并告诉用户和编译器打算怎样来使用它们

接口

interface关键字产生一个完全抽象的类，它根本就没有提供任何具体实现。它允许创建者确定方法名，参数列表和返回类型，但是没有任何方法体。

要让一个类遵循某个特定接口（或者是一组接口），需要使用implements关键字。

interface Instrument {
  int VALUE=5;
  void play(Note n);
  void adjust();
}
class Wind implements Instrument {
  public void play(Note n) {
    System.out.println(this+".play()"+n);
  }
  public String toString(){return "Wind";}
  public void adjust(){
    System.out.println(this+"adjust()");
  }
}
class Percussion implements Instrument{
  public void play(Note n){
    System.out.println(this+"play()"+n);
  }
  public String toString(){return "Percussion";}
  public void adjust(){
    System.out.println(this +"adjust()");
  }
}
class Stringed implements Instrument{
  public void play(Note n){
    System.out.println(this+"play()"+n);
  }
  public String toString(){return "Stringed";}
  public void adjust(){
    System.out.println(this+"adjust()");
  }
}  
class Brass extends Wind{
  public String toString(){return "Brass";}
}
class Windwood extends Wind{
  public String toString(){return "Windwood";}
}
public class Music3 {
  static void tune(Instrument i){
    i.play(Note.MIDDLE_C);
  }
  static void tuneAll(Instrument[] e){
    for(Instrument i:e)
        tune(i);
  }
 public static void main(String[] args){
    Instrument[] orchestra={
            new Wind(),
            new Percussion(),
            new Stringed(),
            new Brass(),
            new Windwood()
    };
    tuneAll(orchestra);
  }
}

Java中的多重继承

在Java中，可以组合多个类的接口，但是只有一个类可以有具体实现。在导出类中，不强制要求必须有一个是抽象的或“具体的”基类。如果要从一个非接口的类继承，那么只能从一个类继承，其余的基元素都必须是接口，需要将所有的接口置于implements关键字后，用逗号隔开。

通过继承来扩展接口

通过继承，可以很容易的在接口中添加新的方法说明，还可以通过继承在新接口中组合数个接口，都可以获得新接口。

interface Monster{
  void menace();
}
interface DangerousMonster extends Monster{
  void destroy();
}
interface Lethal {
  void kill();
}
class DragonZilla implements DangerousMonster {
   public void menace() {}
   public void destroy() {}
}
interface Vampire extends DangerousMonster ,Lethal{
   void drinkBlood();
}
class VeryBadVampire implements Vampire{
   public void menace() {}
   public void destroy() {}
   public void kill() {}
   public void drinkBlood() {}
}
public class HorrorShow {
   static void u(Monster b) {b.menace();}
   static void v(DangerousMonster d) {
      d.menace();
      d.destroy();
   }
   static void w(Lethal l){l.kill();}
   public static void main(String[] args){
      DangerousMonster barney=new DragonZilla();
      u(barney);
      v(barney);
      Vampire vlad=new VeryBadVampire();
      u(vlad);
      v(vlad);
      w(vlad);
  }

}

DangerousMonster是Monster的直接扩展。

一般情况下，只可以将extends用于单一类，但是可以引用多个基类接口，每个接口名用逗号隔开。