http://write.blog.csdn.net/postedit/41129935

首先不懂什麼是interface的可以參考這裡

http://blog.csdn.net/nvd11/article/details/18888415

不過上面的博文只是簡單介紹了interface的語法和用法.  對Interface的用途並沒有介紹清楚. 本文就是1個補充.

一. 對介面的三個疑問

很多初學者都大概清楚interface是1個什麼, 我們可以定義1個介面, 然後在裡面定義一兩個常量(static final) 或抽象方法.

然後以後寫的類就可以實現這個介面, 重寫裡面的抽象方法. 

很多人說介面通常跟多型性一起存在.

介面的用法跟抽象類有點類似.

但是為何要這麼做呢.

1.為什麼不直接在類裡面寫對應的方法,  而要多寫1個介面(或抽象類)?

2.既然介面跟抽象類差不多, 什麼情況下要用介面而不是抽象類.

3. 為什麼interface叫做介面呢? 跟一般範疇的介面例如usb介面, 顯示卡介面有什麼聯絡呢?

二. 介面引用可以指向實現該介面的物件

我們清楚介面是不可以被例項化, 但是介面引用可以指向1個實現該介面的物件.

也就是說.

假如類A impletments 了介面B

那麼下面是合法的:

B b = new A();

也可以把A的物件強制轉換為 介面B的物件

A a = new A90;
B b = (B)a;

這個特性是下面內容的前提.

三. 抽象類為了多型的實現.

第1個答案十分簡單, 就是為了實現多型.

下面用詳細程式碼舉1個例子.

先定義幾個類,

動物(Animal) 抽象類

爬行動物(Reptile) 抽象類  繼承動物類

哺乳動物(Mammal) 抽象類 繼承動物類

山羊(Goat) 繼承哺乳動物類

老虎(Tiger)  繼承哺乳動物類

兔子(Rabbit) 繼承哺乳動物類

蛇(Snake)   繼承爬行動物類

農夫(Farmer)   沒有繼承任何類 但是農夫可以給Animal喂水(依賴關係)

它們的關係如下圖:

3.1 Animal類

這個是抽象類, 顯示也沒有"動物" 這種實體

類裡面包含3個抽象方法.

1. 靜態方法getName()

2. 移動方法move(), 因為動物都能移動.  但是各種動物有不同的移動方法, 例如老虎和山羊會跑著移動, 兔子跳著移動, 蛇會爬著移動.

作為抽象基類, 我們不關心繼承的實體類是如何移動的, 所以移動方法move()是1個抽象方法.  這個就是多型的思想.

3. 喝水方法drink(), 同樣, 各種動物有各種飲水方法. 這個也是抽象方法.

程式碼:

abstract class Animal{
    public abstract String getName();
    public abstract void move(String destination);
    public abstract void drink();
}

3.2 Mammal類

這個是繼承動物類的哺乳動物類, 後面的老虎山羊等都繼承自這個類.

Mammal類自然繼承了Animal類的3個抽象方法, 實體類不再用寫其他程式碼.

abstract class Mammal extends Animal{

}

3.3 Reptile類

這個是代表爬行動物的抽象類, 同上, 都是繼承自Animal類.

abstract class Reptile extends Animal{

}

3.4 Tiger類

老虎類就是1個實體類, 所以它必須重寫所有繼承自超類的抽象方法, 至於那些方法如何重寫, 則取決於老虎類本身.

class Tiger extends Mammal{
    private static String name = "Tiger";
    public String getName(){
        return this.name;
    }

    public void move(String destination){
        System.out.println("Goat moved to " + destination + ".");
    }

    public void drink(){
        System.out.println("Goat lower it's head and drink.");
    }
}

如上, 老虎的移動方法很普通, 低頭喝水.

3.5 Goat類 和 Rabbit類

這個兩個類與Tiger類似, 它們都繼承自Mammal這個類.

class Goat extends Mammal{
    private static String name = "Goat";
    public String getName(){
        return this.name;
    }

    public void move(String destination){
        System.out.println("Goat moved to " + destination + ".");
    }

    public void drink(){
        System.out.println("Goat lower it's head and drink.");
    }
}

兔子: 喝水方法有點區別

class Rabbit extends Mammal{
    private static String name = "Rabbit";
    public String getName(){
        return this.name;
    }

    public void move(String destination){
        System.out.println("Rabbit moved to " + destination + ".");
    }

    public void drink(){
        System.out.println("Rabbit put out it's tongue and drink.");
    }
}

3.6 Snake類

蛇類繼承自Reptile(爬行動物)

移動方法和喝水方法都跟其他3動物有點區別.

class Snake extends Reptile{
    private static String name = "Snake";
    public String getName(){
        return this.name;
    }

    public void move(String destination){
        System.out.println("Snake crawled to " + destination + ".");
    } 

    public void drink(){
        System.out.println("Snake dived into water and drink.");
    }
}

3.7 Farmer 類

Farmer類不屬於 Animal類族, 但是Farmer農夫可以給各種動物, 喂水.

Farmer類有2個關鍵方法, 分別是

bringWater(String destination)    -> 把水帶到某個地點

另1個就是feedWater了, 

feedWater這個方法分為三步:

首先是農夫帶水到飼養室,(bringWater())

接著被喂水動物走到飼養室,(move())

接著動物喝水(drink())

Farmer可以給老虎喂水, 可以給山羊喂水, 還可以給蛇喂水, 那麼feedWater()裡的引數型別到底是老虎,山羊還是蛇呢.

實際上因為老虎,山羊, 蛇都繼承自Animal這個類, 所以feedWater裡的引數型別設為Animal就可以了.

Farmer類首先叼用bringWater("飼養室"),

至於這個動物是如何走到飼養室和如何喝水的, Farmer類則不用關心.

因為執行時, Animal超類會根據引用指向的物件型別不同 而 指向不同的被重寫的方法.  這個就是多型的意義.

程式碼如下:

class Farmer{
    public void bringWater(String destination){
        System.out.println("Farmer bring water to " + destination + ".");
    }

    public void feedWater(Animal a){ // polymorphism
        this.bringWater("Feeding Room");
        a.move("Feeding Room");
        a.drink();
    }

}

3.7 執行農夫喂水的程式碼.

下面的程式碼是1個農夫依次喂水給一隻老虎, 一隻羊, 以及一條蛇

 public static void f(){
        Farmer fm = new Farmer();
        Snake sn = new Snake();
        Goat gt = new Goat();
        Tiger tg = new Tiger();

        fm.feedWater(sn);
        fm.feedWater(gt);
        fm.feedWater(tg);
    }

農夫只負責帶水過去制定地點, 而不必關心老虎, 蛇, 山羊它們是如何過來的. 它們如何喝水. 這些農夫都不必關心.

只需要呼叫同1個方法feedWater.  

執行結果:

   [java] Farmer bring water to Feeding Room.
     [java] Snake crawled to Feeding Room.
     [java] Snake dived into water and drink.
     [java] Farmer bring water to Feeding Room.
     [java] Goat moved to Feeding Room.
     [java] Goat lower it's head and drink.
     [java] Farmer bring water to Feeding Room.
     [java] Goat moved to Feeding Room.
     [java] Goat lower it's head and drink.

不使用多型的後果?:

而如果老虎, 蛇, 山羊的drink() 方法不是重寫自同1個抽象方法的話, 多型就不能實現.

農夫類就可能要根據引數型別的不同而過載很多個  feedWater()方法了.

而且每增加1個類(例如 獅子Lion)

就需要在農夫類裡增加1個feedWater的過載方法 feedWater(Lion l)...

而介面跟抽象類類似,

這個就回答了不本文第一個問題.

1.為什麼不直接在類裡面寫對應的方法,  而要多寫1個介面(或抽象類)?

四. 抽象類解決不了的問題.

既然抽象類很好地實現了多型性, 那麼什麼情況下用介面會更加好呢?

對於上面的例子, 我們加一點需求.

Farmer 農夫多了1個技能, 就是給另1個動物喂兔子(囧).

BringAnimal(Animal a, String destination)     把兔子帶到某個地點...

feedAnimal(Animal ht, Animal a)            把動物a丟給動物ht

注意農夫並沒有把兔子宰了, 而是把小動物(a)丟給另1個被餵食的動物(ht).

那麼問題來了, 那個動物必須有捕獵這個技能.  也就是我們要給被餵食的動物加上1個方法(捕獵) hunt(Animal a).

但是現實上不是所有動物都有捕獵這個技能的, 所以我們不應該把hunt(Animal a)方法加在Goat類和Rabbit類裡,  只加在Tiger類和Snake類裡.

而且老虎跟蛇的捕獵方法也不一樣, 則表明hunt()的方法體在Tiger類裡和Snake類裡是不一樣的.

下面有3個方案.

1. 分別在Tiger類裡和Snake類里加上Hunt() 方法.  其它類(例如Goat) 不加.

2. 在基類Animal里加上Hunt()抽象方法. 在Tiger裡和Snake裡重寫這個Hunt() 方法.

3. 新增肉食性動物這個抽象類.   

先來說第1種方案.

這種情況下, Tiger裡的Hunt(Animal a)方法與 Snake裡的Hunt(Animal a)方法毫無關聯. 也就是說不能利用多型性.

導致Farm類裡的feedAnimal()方法需要分別為Tiger 與 Snake類過載. 否決.

第2種方案:

如果在抽象類Animal里加上Hunt()方法, 則所有它的非抽象派生類都要重寫實現這個方法, 包括 Goat類和 Rabbit類.

這是不合理的, 因為Goat類根本沒必要用到Hunt()方法, 造成了資源(記憶體)浪費.

第3種方案:

加入我們在哺乳類動物下做個分叉, 加上肉食性哺乳類動物, 非肉食性哺乳動物這兩個抽象類?

首先,

肉食性這種分叉並不準確, 例如很多腐蝕性動物不會捕獵, 但是它們是肉食性.

其次

這種方案會另類族圖越來越複雜, 假如以後再需要辨別能否飛的動物呢, 增加飛翔 fly()這個方法呢? 是不是還要分叉?

再次,

很現實的問題, 在專案中, 你很可能沒機會修改上層的類程式碼, 因為它們是用Jar包釋出的, 或者你沒有修改許可權.

這種情況下就需要用到介面了.

五.介面與多型 以及 多繼承性.

上面的問題, 抽象類解決不了, 根本問題是Java的類不能多繼承.

因為Tiger類繼承了動物Animal類的特性(例如 move() 和 drink()) , 但是嚴格上來將 捕獵(hunt())並不算是動物的特性之一. 有些植物, 單細胞生物也會捕獵的.

所以Tiger要從別的地方來繼承Hunt()這個方法.  介面就發揮作用了.

修改後的UML圖如下:

5.1 Huntable介面

由UML圖可知,

我們增加了1個Huntable介面.

接口裡有1個方法hunt(Animal a), 就是捕捉動物, 至於怎樣捕捉則由實現介面的類自己決定.

程式碼:

interface Huntable{
    public void hunt(Animal a);
}

5.2 Tiger 類

既然定義了1個Huntable(可以捕獵的)介面.

Tiger類就要實現這個介面並重寫接口裡hunt()方法.

class Tiger extends Mammal implements Huntable{
    private static String name = "Tiger";
    public String getName(){
        return this.name;
    }

    public void move(String destination){
        System.out.println("Goat moved to " + destination + ".");
    }

    public void drink(){
        System.out.println("Goat lower it's head and drink.");
    }

    public void hunt(Animal a){
        System.out.println("Tiger catched " + a.getName() + " and eated it");
    }

}

5.3 Snake類

同樣:

class Snake extends Reptile implements Huntable{
    private static String name = "Snake";
    public String getName(){
        return this.name;
    }

    public void move(String destination){
        System.out.println("Snake crawled to " + destination + ".");
    } 

    public void drink(){
        System.out.println("Snake dived into water and drink.");
    }

    public void hunt(Animal a){
        System.out.println("Snake coiled " + a.getName() + " and eated it");
    }
}

可見同樣實現介面的hunt()方法, 但是蛇與老虎的捕獵方法是有區別的.

5.4 Farmer類

這樣的話. Farmer類裡的feedAnimal(Animal ht, Animal a)就可以實現多型了.

class Farmer{
    public void bringWater(String destination){
        System.out.println("Farmer bring water to " + destination + ".");
    }
    
    public void bringAnimal(Animal a,String destination){
        System.out.println("Farmer bring " + a.getName() + " to " + destination + ".");
    }

    public void feedWater(Animal a){
        this.bringWater("Feeding Room");
        a.move("Feeding Room");
        a.drink();
    }

    public void feedAnimal(Animal ht , Animal a){
        this.bringAnimal(a,"Feeding Room");
        ht.move("Feeding Room");
        Huntable hab = (Huntable)ht;
        hab.hunt(a);
    }

}

關鍵是這一句

Huntable hab = (Huntable)ht;

本文一開始講過了, 介面的引用可以指向實現該介面的物件.

當然, 如果把Goat物件傳入Farmer的feedAnimal()裡就會有異常, 因為Goat類沒有實現該介面. 上面那個程式碼執行失敗.

如果要避免上面的問題.

可以修改feedAnimal方法:

    public void feedAnimal(Huntable hab, Animal a){
        this.bringAnimal(a,"Feeding Room");
        Animal ht = (Animal)hab;
        ht.move("Feeding Room");
        hab.hunt(a);
    }

這樣的話, 傳入的物件就必須是實現了Huntable的物件, 如果把Goat放入就回編譯報錯.

但是裡面一樣有一句強制轉換

Animal ht = (Animal)hab

反而更加不安全, 因為實現的Huntable的介面的類不一定都是Animal的派生類.

相反, 介面的出現就是鼓勵多種不同的類實現同樣的功能(方法)

例如,假如一個機械類也可以實現這個介面, 那麼那個機械就可以幫忙打獵了(囧)

1個植物類(例如捕蠅草),實現這個介面, 也可以捕獵蒼蠅了.

也就是說, 介面不會限制實現介面的類的型別.

執行輸出:

     [java] Farmer bring Rabbit to Feeding Room.
     [java] Snake crawled to Feeding Room.
     [java] Snake coiled Rabbit and eated it
     [java] Farmer bring Rabbit to Feeding Room.
     [java] Goat moved to Feeding Room.
     [java] Tiger catched Rabbit and eated it

這樣, Tiger類與Snake類不但繼承了Animal的方法, 還繼承(實現)了介面Huntable的方法, 一定程度上彌補java的class不支援多繼承的特點.

六.介面上應用泛型.

上面的Huntable裡還是有點限制的,

就是它裡面的hunt()方法的引數是 Animal a, 也就是說這個這個介面只能用於捕獵動物.

但是在java的世界裡, 接口裡的方法(行為)大多數是與類的型別無關的.

也就是說, Huntable接口裡的hunt()方法裡不單隻可以捕獵動物, 還可以捕獵其他東西(例如 捕獵植物... 敵方機械等)

6.1 Huntable介面

首先要在Huntable介面上新增泛型標誌:<T>

interface Huntable<T>{
    public void hunt(T o);
}

然後裡面的hunt()的引數的型別就寫成T, 表示hunt()方法可以接受多種引數, 取決於實現介面的類.

6.2 Tiger類(和Snake類)

同樣, 定義tiger類時必須加上介面的泛型標誌<Animal>, 表示要把介面應用在Animal這種型別.

class Tiger extends Mammal implements Huntable<Animal>{
    private static String name = "Tiger";
    public String getName(){
        return this.name;
    }

    public void move(String destination){
        System.out.println("Goat moved to " + destination + ".");
    }

    public void drink(){
        System.out.println("Goat lower it's head and drink.");
    }

    public void hunt(Animal a){
        System.out.println("Tiger catched " + a.getName() + " and eated it");
    }

}

這樣, 在裡面hunt()引數就可以指明型別Animal了,  表示老虎雖然有捕獵這個行為, 但是隻能捕獵動物.

七.什麼情況下應該使用介面而不用抽象類.

好了, 回到本文最重要的一個問題.

做個總結

1. 需要實現多型

2. 要實現的方法(功能)不是當前類族的必要(屬性).

3. 要為不同類族的多個類實現同樣的方法(功能).

下面是分析:

7.1 需要實現多型

很明顯, 介面其中一個存在意義就是為了實現多型. 這裡不多說了.

而抽象類(繼承) 也可以實現多型

7.2. 要實現的方法(功能)不是當前類族的必要(屬性).

上面的例子就表明, 捕獵這個方法不是動物這個類必須的,

在動物的派生類中, 有些類需要, 有些不需要.  

如果把捕獵方法解除安裝動物超類裡面是不合理的浪費資源.

所以把捕獵這個方法封裝成1個介面, 讓派生類自己去選擇實現!

7.3. 要為不同類族的多個類實現同樣的方法(功能).

上面說過了, 其實不是隻有Animal類的派生類才可以實現Huntable介面.

如果Farmer實現了這個介面, 那麼農夫自己就可以去捕獵動物了...

我們拿另個常用的介面Comparable來做例子.

這個介面是應用了泛型,

首先, 比較(CompareTo) 這種行為很難界定適用的類族, 實際上, 幾乎所有的類都可以比較.

比如 數字類可以比較大小,   人類可以比較財富,  動物可以比較體重等.

所以各種類都可以實現這個比較介面.

一旦實現了這個比較介面. 就可以開啟另1個隱藏技能:

就是可以利用Arrays.sort()來進行排序了.

就如實現了捕獵的動物,

可以被農夫Farmer喂兔子一樣...

八.介面為什麼會被叫做介面, 跟真正的介面例如usb介面有聯絡嗎?

對啊, 為什麼叫介面, 而不叫外掛(plugin)呢,  貌似java介面的功能更類似1個外掛啊.

插上某個外掛, 就有某個功能啊.

實際上, 外掛與介面是相輔相成的.

例如有1個外部儲存外掛(U盤), 也需要使用裝置具有usb接口才能使用啊.

再舉個具體的例子.

個人電腦是由大型機發展而來的

大型機->小型機->微機(PC)

而筆記本是繼承自微機的.

那麼問題來了.

對於, 計算機的CPU/記憶體/主機板/獨顯/光碟機/印表機 有很多功能(方法/行為), 那麼到底哪些東西是繼承, 哪些東西是介面呢.

首先,  cpu/記憶體/主機板 是從大型機開始都必備的, 任何計算機都不能把它們去掉.

所以, 這三樣東西是繼承的, 也就說筆記本的cpu/記憶體/主機板是繼承自微機(PC)的

但是/光碟機/呢,    現實上很多超薄筆記本不需要光碟機的功能.

如果光碟機做成繼承, 那麼筆記本就必須具有光碟機, 然後遮蔽光碟機功能, 那麼這檯筆記本還能做到超薄嗎? 浪費了資源.

所以光碟機,印表機這些東西就應該做成外掛.

然後, 在筆記本上做1個可以插光碟機和印表機的介面(usb介面).

也就是說, PC的派生類, 有些(筆記本)可以不實現這個介面, 有些(桌上型電腦)可以實現這個介面,只需要把光碟機插到這個介面上.

至於光碟機是如何實現的,

例如一些pc派生類選擇實現藍光光碟機, 有些選擇燒錄機.  但是usb介面本身並不關心. 取決與實現介面的類.

這個就是現實意義上的多型性啊.