java-接口（interface）

一、接口的定义

1.定义：接口是常量和方法的集合，这些方法只有声明没有实现。

2.作用：实现多重继承。

3.声明的格式(使用interface关键字)：

[public] interface InterfaceName [extends SuperInterfaces]{

[public] [static] [final] type name=value;

[public] [abstract] returnType methodName([paramlist]);

}

4.注意：

（1）接口中常量的定义可以默认修饰符，但系统会自动加上public、final、static属性（常量）。

（2）接口中的方法没有实现，也可以默认修饰符，但系统会自动加上public、abstract属性。

（3）接口中的所有方法都是抽象方法。接口比抽象类还抽象。

（4）一个接口可以继承一个或多个接口。

（5）如果子接口中定义了和超接口中同名的常量和相同的方法，则超接口中的常量被隐藏，方法被覆盖。

（6）接口不能被类继承，只能被类实现。接口被接口继承。

二、接口的实现

1.接口只能被类实现（使用implements关键字）。格式：

[public] class ClassName implements InterfaceList{

//类体

}

2.注意：

（1）一个类可以实现多个接口，用逗号隔开。（多继承）

（2）如果实现接口的类不是抽象类，在类的定义部分必须实现接口中的所有抽象方法。（保证非抽象类中无抽象方法）

（3）类在实现接口的抽象方法时，必须是相同的方法签名，否则是重载。

（4）因为接口中的方法都默认public修饰，所有在类中实现时，必须显式使用public修饰符。

三、关于多继承问题

1.一个类只能继承一个类，但可以实现多个接口。

2.可以说是为了说明这样一句话:一个x是一个a和一个b和一个c。

3.代码实例：

import java.util.*;

interface CanFight {
  void fight();
}

interface CanSwim {
  void swim();
}

interface CanFly {
  void fly();
}

class ActionCharacter {
  public void fight() {}
}

class Hero extends ActionCharacter  implements CanFight, CanSwim, CanFly {
//先extends再implements
  public void swim() {}
  public void fly() {}
}

public class Adventure {
  static void t(CanFight x) { x.fight(); }
  static void u(CanSwim x) { x.swim(); }
  static void v(CanFly x) { x.fly(); }
  static void w(ActionCharacter x) { x.fight(); }
  public static void main(String[] args) {
    Hero h = new Hero();
    t(h); // Treat it as a CanFight
    u(h); // Treat it as a CanSwim
    v(h); // Treat it as a CanFly
    w(h); // Treat it as an ActionCharacter
  }
} 

关于上面的代码作如下说明：

（1）Hero类中没有定义fight方法，但是这个方法的定义可以跟随超类ActionCharacter而来，所以不会报错。

（2）创建了一个Hero对象后，它可以被传递给那4个方法，在程序中会被依次向上转型为每一个接口以及一个超类。

4.使用接口的核心原因：能够向上转型为多个基类型。

四、扩展接口

通过继承一个接口添加新的方法声明，或者通过继承在新接口中组合多个接口，都可以获得新的接口。

extends用来继承一个类，但可以继承多个接口（接口继承接口也用extends）。

代码实例：

interface Monster {
  void menace();
}

interface DangerousMonster extends Monster {//接口继承接口用extends
  void destroy();
}

interface Lethal {
  void kill();
}

class DragonZilla implements DangerousMonster {
  public void menace() {}
  public void destroy() {}
}

interface Vampire 
    extends DangerousMonster, Lethal {
  void drinkBlood();
}

class HorrorShow {
  static void u(Monster b) { b.menace(); }
  static void v(DangerousMonster d) {
    d.menace();
    d.destroy();
  }
  public static void main(String[] args) {
    DragonZilla if2 = new DragonZilla();
    u(if2);
    v(if2);
  }
} 

参考资料：

《java语言程序设计》——清华大学出版社

《Java编程思想》——机械工业出版社