# 7.5 接口 `interface`（接口）關鍵字使抽象的概念更深入了一層。我們可將其想象為一個“純”抽象類。它允許創建者規定一個類的基本形式：方法名、參數列表以及返回類型，但不規定方法主體。接口也包含了基本數據類型的數據成員，但它們都默認為`static`和`final`。接口只提供一種形式，并不提供實現的細節。 接口這樣描述自己：“對于實現我的所有類，看起來都應該象我現在這個樣子”。因此，采用了一個特定接口的所有代碼都知道對于那個接口可能會調用什么方法。這便是接口的全部含義。所以我們常把接口用于建立類和類之間的一個“協議”。有些面向對象的程序設計語言采用了一個名為`protocol`（協議）的關鍵字，它做的便是與接口相同的事情。 為創建一個接口，請使用`interface`關鍵字，而不要用`class`。與類相似，我們可在`interface`關鍵字的前面增加一個`public`關鍵字（但只有接口定義于同名的一個文件內）；或者將其省略，營造一種“友好的”狀態。 為了生成與一個特定的接口（或一組接口）相符的類，要使用`implements`（實現）關鍵字。我們要表達的意思是“接口看起來就象那個樣子，這兒是它具體的工作細節”。除這些之外，我們其他的工作都與繼承極為相似。下面是樂器例子的示意圖：  具體實現了一個接口以后，就獲得了一個普通的類，可用標準方式對其進行擴展。 可決定將一個接口中的方法聲明明確定義為`public`。但即便不明確定義，它們也會默認為`public`。所以在實現一個接口的時候，來自接口的方法必須定義成`public`。否則的話，它們會默認為“友好的”，而且會限制我們在繼承過程中對一個方法的訪問——Java編譯器不允許我們那樣做。 在`Instrument`例子的修改版本中，大家可明確地看出這一點。注意接口中的每個方法都嚴格地是一個聲明，它是編譯器唯一允許的。除此以外，`Instrument5`中沒有一個方法被聲明為`public`，但它們都會自動獲得`public`屬性。如下所示： ``` //: Music5.java // Interfaces import java.util.*; interface Instrument5 { // Compile-time constant: int i = 5; // static & final // Cannot have method definitions: void play(); // Automatically public String what(); void adjust(); } class Wind5 implements Instrument5 { public void play() { System.out.println("Wind5.play()"); } public String what() { return "Wind5"; } public void adjust() {} } class Percussion5 implements Instrument5 { public void play() { System.out.println("Percussion5.play()"); } public String what() { return "Percussion5"; } public void adjust() {} } class Stringed5 implements Instrument5 { public void play() { System.out.println("Stringed5.play()"); } public String what() { return "Stringed5"; } public void adjust() {} } class Brass5 extends Wind5 { public void play() { System.out.println("Brass5.play()"); } public void adjust() { System.out.println("Brass5.adjust()"); } } class Woodwind5 extends Wind5 { public void play() { System.out.println("Woodwind5.play()"); } public String what() { return "Woodwind5"; } } public class Music5 { // Doesn't care about type, so new types // added to the system still work right: static void tune(Instrument5 i) { // ... i.play(); } static void tuneAll(Instrument5[] e) { for(int i = 0; i < e.length; i++) tune(e[i]); } public static void main(String[] args) { Instrument5[] orchestra = new Instrument5[5]; int i = 0; // Upcasting during addition to the array: orchestra[i++] = new Wind5(); orchestra[i++] = new Percussion5(); orchestra[i++] = new Stringed5(); orchestra[i++] = new Brass5(); orchestra[i++] = new Woodwind5(); tuneAll(orchestra); } } ///:~ ``` 代碼剩余的部分按相同的方式工作。我們可以自由決定向上轉換到一個名為`Instrument5`的“普通”類，一個名為`Instrument5`的“抽象”類，或者一個名為`Instrument5`的“接口”。所有行為都是相同的。事實上，我們在`tune()方`法中可以發現沒有任何證據顯示`Instrument5`到底是個“普通”類、“抽象”類還是一個“接口”。這是做是故意的：每種方法都使程序員能對對象的創建與使用進行不同的控制。 ## 7.5.1 Java的“多重繼承” 接口只是比抽象類“更純”的一種形式。它的用途并不止那些。由于接口根本沒有具體的實現細節——也就是說，沒有與存儲空間與“接口”關聯在一起——所以沒有任何辦法可以防止多個接口合并到一起。這一點是至關重要的，因為我們經常都需要表達這樣一個意思：“`x`從屬于`a`，也從屬于`b`，也從屬于`c`”。在C++中，將多個類合并到一起的行動稱作“多重繼承”，而且操作較為不便，因為每個類都可能有一套自己的實現細節。在Java中，我們可采取同樣的行動，但只有其中一個類擁有具體的實現細節。所以在合并多個接口的時候，C++的問題不會在Java中重演。如下所示：  在一個派生類中，我們并不一定要擁有一個抽象或具體（沒有抽象方法）的基類。如果確實想從一個非接口繼承，那么只能從一個繼承。剩余的所有基本元素都必須是“接口”。我們將所有接口名置于`implements`關鍵字的后面，并用逗號分隔它們。可根據需要使用多個接口，而且每個接口都會成為一個獨立的類型，可對其進行向上轉換。下面這個例子展示了一個“具體”類同幾個接口合并的情況，它最終生成了一個新類： ``` //: Adventure.java // Multiple interfaces 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 { 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 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設計的，所以這樣做不會有任何問題，而且程序員不必對此加以任何特別的關注。 注意上述例子已向我們揭示了接口最關鍵的作用，也是使用接口最重要的一個原因：能向上轉換至多個基類。使用接口的第二個原因與使用抽象基類的原因是一樣的：防止客戶程序員制作這個類的一個對象，以及規定它僅僅是一個接口。這樣便帶來了一個問題：到底應該使用一個接口還是一個抽象類呢？若使用接口，我們可以同時獲得抽象類以及接口的好處。所以假如想創建的基類沒有任何方法定義或者成員變量，那么無論如何都愿意使用接口，而不要選擇抽象類。事實上，如果事先知道某種東西會成為基類，那么第一個選擇就是把它變成一個接口。只有在必須使用方法定義或者成員變量的時候，才應考慮采用抽象類。 ## 7.5.2 通過繼承擴展接口 利用繼承技術，可方便地為一個接口添加新的方法聲明，也可以將幾個接口合并成一個新接口。在這兩種情況下，最終得到的都是一個新接口，如下例所示： ``` //: HorrorShow.java // Extending an interface with inheritance 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`可能引用多個基礎接口。正如大家看到的那樣，接口的名字只是簡單地使用逗號分隔。 ## 7.5.3 常數分組 由于置入一個接口的所有字段都自動具有`static`和`final`屬性，所以接口是對常數值進行分組的一個好工具，它具有與C或C++的`enum`非常相似的效果。如下例所示： ``` //: Months.java // Using interfaces to create groups of constants package c07; public interface Months { int JANUARY = 1, FEBRUARY = 2, MARCH = 3, APRIL = 4, MAY = 5, JUNE = 6, JULY = 7, AUGUST = 8, SEPTEMBER = 9, OCTOBER = 10, NOVEMBER = 11, DECEMBER = 12; } ///:~ ``` 注意根據Java命名規則，擁有固定標識符的`static final`基本數據類型（亦即編譯期常數）都全部采用大寫字母（用下劃線分隔單個標識符里的多個單詞）。 接口中的字段會自動具備`public`屬性，所以沒必要專門指定。 現在，通過導入 `c07.*` 或 `c07.Months` ，我們可以從包的外部使用常數——就象對其他任何包進行的操作那樣。此外，也可以用類似`Months.JANUARY`的表達式對值進行引用。當然，我們獲得的只是一個`int`，所以不象C++的`enum`那樣擁有額外的類型安全性。但與將數字強行編碼（硬編碼）到自己的程序中相比，這種（常用的）技術無疑已經是一個巨大的進步。我們通常把“硬編碼”數字的行為稱為“魔術數字”，它產生的代碼是非常難以維護的。 如確實不想放棄額外的類型安全性，可構建象下面這樣的一個類（注釋①）： ``` //: Month2.java // A more robust enumeration system package c07; public final class Month2 { private String name; private Month2(String nm) { name = nm; } public String toString() { return name; } public final static Month2 JAN = new Month2("January"), FEB = new Month2("February"), MAR = new Month2("March"), APR = new Month2("April"), MAY = new Month2("May"), JUN = new Month2("June"), JUL = new Month2("July"), AUG = new Month2("August"), SEP = new Month2("September"), OCT = new Month2("October"), NOV = new Month2("November"), DEC = new Month2("December"); public final static Month2[] month = { JAN, JAN, FEB, MAR, APR, MAY, JUN, JUL, AUG, SEP, OCT, NOV, DEC }; public static void main(String[] args) { Month2 m = Month2.JAN; System.out.println(m); m = Month2.month[12]; System.out.println(m); System.out.println(m == Month2.DEC); System.out.println(m.equals(Month2.DEC)); } } ///:~ ``` ①：是Rich Hoffarth的一封E-mail觸發了我這樣編寫程序的靈感。 這個類叫作`Month2`，因為標準Java庫里已經有一個`Month`。它是一個`final`類，并含有一個`private`構造器，所以沒有人能從它繼承，或制作它的一個實例。唯一的實例就是那些`final static`對象，它們是在類本身內部創建的，包括：`JAN`，`FEB`，`MAR`等等。這些對象也在`month`數組中使用，后者讓我們能夠按數字挑選月份，而不是按名字（注意數組中提供了一個多余的`JAN`，使偏移量增加了1，也使`December`確實成為12月）。在`main()`中，我們可注意到類型的安全性：`m`是一個`Month2`對象，所以只能將其分配給`Month2`。在前面的`Months.java`例子中，只提供了`int`值，所以本來想用來代表一個月份的`int`變量可能實際獲得一個整數值，那樣做可能不十分安全。 這兒介紹的方法也允許我們交換使用`==`或者`equals()`，就象`main()`尾部展示的那樣。 ## 7.5.4 初始化接口中的字段 接口中定義的字段會自動具有`static`和`final`屬性。它們不能是“空白`final`”，但可初始化成非常數表達式。例如： ``` //: RandVals.java // Initializing interface fields with // non-constant initializers import java.util.*; public interface RandVals { int rint = (int)(Math.random() * 10); long rlong = (long)(Math.random() * 10); float rfloat = (float)(Math.random() * 10); double rdouble = Math.random() * 10; } ///:~ ``` 由于字段是`static`的，所以它們會在首次裝載類之后、以及首次訪問任何字段之前獲得初始化。下面是一個簡單的測試： ``` //: TestRandVals.java public class TestRandVals { public static void main(String[] args) { System.out.println(RandVals.rint); System.out.println(RandVals.rlong); System.out.println(RandVals.rfloat); System.out.println(RandVals.rdouble); } } ///:~ ``` 當然，字段并不是接口的一部分，而是保存于那個接口的`static`存儲區域中。