接口与多重继承

为了生成与一个特定的接口（或一组接口）相符的类，要使用 implements（实现）关键字。我们要表达的意思是“接口看起来就象那个样子，这儿是它具体的工作细节”。

下面是Java 的“多重继承”的例子：

interface CanFight {
    void fight();
}
interface CanSwim {
    void swim();
}
interface CanFly {
    void fly();
}
class ActionCharacter {
    public void fight() {
        System.out.println("ActionCharacter can fight");
    }
}
class Hero extends ActionCharacter
        implements CanFight, CanSwim, CanFly {
    @Override
    public void swim() {
        System.out.println("hero can swim");
    }
    @Override
    public void fly() {
        System.out.println("hero can 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 i = new Hero();
        t(i); // Treat it as a CanFight
        u(i); // Treat it as a CanSwim
        v(i); // Treat it as a CanFly
        w(i); // Treat it as an ActionCharacter
    }
}

从中可以看到，Hero 将具体类ActionCharacter 同接口 CanFight，CanSwim 以及CanFly 合并起来。按这种形式合并一个具体类与接口的时候，具体类必须首先出现，然后才是接口（否则编译器会报错）。

请注意 fight()的签名在CanFight 接口与 ActionCharacter 类中是相同的，而且没有在Hero 中为fight()提
供一个具体的定义。接口的规则是：我们可以从它继承（稍后就会看到），但这样得到的将是另一个接口。

如果想创建新类型的一个对象，它就必须是已提供所有定义的一个类。尽管Hero 没有为 fight()明确地提供一个定义，但定义是随同ActionCharacter 来的，所以这个定义会自动提供，我们可以创建Hero 的对象。在类Adventure 中，我们可看到共有四个方法，它们将不同的接口和具体类作为自己的自变量使用。创建一个Hero 对象后，它可以传递给这些方法中的任何一个。这意味着它们会依次上溯造型到每一个接口。由于接口是用 Java 设计的，所以这样做不会有任何问题，而且程序员不必对此加以任何特别的关注。

注意上述例子已向我们揭示了接口最关键的作用，也是使用接口最重要的一个原因：能上溯造型至多个基础类。使用接口的第二个原因与使用抽象基础类的原因是一样的：防止客户程序员制作这个类的一个对象，以及规定它仅仅是一个接口。

这样便带来了一个问题：到底应该使用一个接口还是一个抽象类呢？若使用接口，我们可以同时获得抽象类以及接口的好处。所以假如想创建的基础类没有任何方法定义或者成员变量，那么无论如何都愿意使用接口，而不要选择抽象类。事实上，如果事先知道某种东西会成为基础类，那么第一个选择就是把它变成一个接口。只有在必须使用方法定义或者成员变量的时候，才应考虑采用抽象类。

通过接口间的继承来扩展接口：

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 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);
 }
} 

DangerousMonster 是对Monster 的一个简单的扩展，最终生成了一个新接口。这是在DragonZilla 里实现的。

Vampire 的语法仅在继承接口时才可使用。通常，我们只能对单独一个类应用 extends（扩展）关键字。但由于接口可能由多个其他接口构成，所以在构建一个新接口时，extends 可能引用多个基础接口。正如大家看到的那样，接口的名字只是简单地使用逗号分隔