Java 接口（interface）的作用與好處

2019-11-14 08:44:57

字體：大中小

來源：轉載

供稿：網友

首先提出兩個問題：

一、明明可以在類中直接寫所需的方法，為什么還要多寫一個接口（或抽象類）？二、抽象類和接口都差不多，在什么時候才選擇使用接口？

一、抽象類為了多態的實現

假設現在有7個類，分別如下： 1. 動物（Animal）抽象類 2. 哺乳動物（Mammal）抽象類繼承動物類 3. 爬行動物（Reptile）抽象類繼承動物類 4. 老虎（Tiger）繼承爬行動物類 5. 蛇類（Snake）繼承爬行動物類 6. 兔子（Rabbit）繼承哺乳動物類 7. 農夫（Farmer）農夫可以喂養Animal

1. Animal類

動物都會行走，喝水，代碼如下

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

2. Mammal類

abstract class Mammal extends Animal{ //繼承動物類的兩個抽象方法，該類為抽象類，不用具體實現}

3. Raptile類

abstract class Raptile extends Animal{ //繼承動物類的兩個抽象方法，該類為抽象類，不用具體實現}

4. Tiger類

public class Tiger extends Mammal{ PRivate static String name = "Tiger"; public String getName(){ return this.name; } public void move(){ System.out.println("Tiger moved to " + destination + "."); } public void drink(){ System.out.println("Tiger down to drink water"); }}

5. Snake類

public class Snake extends Raptile{ private static String name = "Snake"; public String getName(){ return this.name; } public void move(){ System.out.println("Snake moved to " + destination + "."); } public void drink(){ System.out.println("Snake stretched his tongue to drink water"); }}

6. Rabbit類

public class Rabbit extends Mammal{ private static String name = "Rabbit"; public String getName(){ return this.name; } public void move(){ System.out.println("Rabbit moved to " + destination + "."); } public void drink(){ System.out.println("Rabbit put out it's tongue and drink."); }}

7. Farmer類

農夫沒有繼承任何類，但農夫可以給動物喂水喝，而不關心給什么動物喂水喝，也不關心動物們從哪里來。

public class farmer{ public void bringWater(String destination){ System.out.println("Farmer bring water to " + destination +"."); } public void feedWater(Animal animal, String destination){ this.bringWater(destination); animal.move(destination); animal.drink(); }}

農夫依次去三個地方給三只動物喂水，執行Farmer喂水代碼

public void f(){ Tiger tiger = new Tiger(); Snake snake = new Snake(); Rabbit rabbit = new Rabbit(); Farmer farmer = new Farmer(); farmer.feedWater(tiger, room); farmer.feedWater(snake, grassland); farmer.feedWater(rabbit, kichen);}

執行結果：

[java] Farmer bring water to room. [java] Tiger moved to room. [java] Tiger down to drink water. [java] Farmer bring water to grassland. [java] Snake moved to grassland. [java] Snake stretched his tongue to drink water. [java] Farmer bring water to kichen. [java] Rabbit moved to kichen. [java] Rabbit put out it's tongue and drink.

如果老虎、蛇、兔子沒有繼承抽象類來重寫同一個抽象方法，多態就不能實現這樣的話，農夫類就要根據參數類型重載多個feedwater()方法，像這樣：

feedwater(Tiger tiger, String destination);feedwater(Snake snake, String destination);...

Tiger、Snake、Rabbit繼承了Raptile、Mammer抽象類，而Raptile、Mammer類繼承基類Animal抽象類，所以Tiger、Snake、Rabbit都向上轉型為Animal類，例如可以把農夫喂水的執行代碼寫成下面這樣：

public void f(){ Animal tiger = new Tiger(); Animal snake = new Snake(); Animal rabbit = new Rabbit(); Farmer farmer = new Farmer(); farmer.feedWater(tiger, room); farmer.feedWater(snake, grassland); farmer.feedWater(rabbit, kichen);}

既然抽象類與接口都能實現多態，那什么時候才需要使用接口呢？

二、接口的使用

假設現在農夫學會了一個新方法，帶動物讓Tiger和Snake捕食，需要給Tiger、Snake加一個捕食方法hunt()，Rabbit則不需要此方法。但從以上類中發現，Snake、Tiger繼承于Raptile、Mammer抽象類，Mammer的子類中有Rabbit類，則hunt()方法不能直接寫入Animal類中，因為寫在Animal類中，Animal的所有方法將會直接繼承到子類中，由于Rabbit類用不上hunt()方法，則會造成資源浪費。現在考慮幾種方案： 1. 直接將hunt()方法寫在各肉食動物的類中若這樣做，就不能實現多態，每個類中的hunt()方法只能由類對象進行調用，像這樣：

Tiger tiger = new Tiger();tiger.hunt(animal);Snake snake = new Snake();snake.hunt(animal);

此時農夫類像這樣，需要對Tiger、Snake類方法重載：

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 animal, String destination){ this.bringWater(destination); animal.move(destination); animal.drink(); } public void feedAnimal(Tiger tiger , Animal animal){ this.bringAnimal(animal,"Feeding Room"); tiger.move("Feeding Room"); tiger.hunt(animal); } public void feedAnimal(Snake snake, Animal animal){ snake.bringAnimal(animal,"Feeding Room"); snake.move("Feeding Room"); snake.hunt(animal); } }

若有很多會捕食的動物，將需要大量重載，所以這個方案不可以取。 2. 增加肉食動物抽象類如果是加入肉食動物類與非肉食動物類，將會使得類族圖復雜化，因為肉食動物中也有不會捕獵的動物。

這個時候就需要用到接口了。

1. Hunt接口

interface Hunt{ public void hunt(Animal animal);}

定義好了接口之后，直接由Tiger、Snake遵循這個接口，需要用到implements關鍵字：

2. Tiger類

public class Tiger extends Mammal implements Hunt{ private static String name = "Tiger"; public String getName(){ return this.name; } public void move(){ System.out.println("Tiger moved to " + destination + "."); } public void drink(){ System.out.println("Tiger down to drink water"); } public void hunt(Animal animal){ System.out.println("Tiger catched a " + animal.getName() + "and eated it." ) }}

3. Snake類

public class Snake extends Raptile implements Hunt{ private static String name = "Snake"; public String getName(){ return this.name; } public void move(){ System.out.println("Snake moved to " + destination + "."); } public void drink(){ System.out.println("Snake stretched his tongue to drink water"); } public void hunt(Animal animal){ System.out.println("Tiger catched a " + animal.getName() + "and eated it." ) }}

4. Farmer類

public 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 animal, String destination){ this.bringWater(destination); animal.move(destination); animal.drink(); } public void feedAnimal(Hunt hunter, Animal animal){ this.bringAnimal(animal,"Feeding Room"); Animal ht = (Animal)hunter; ht.move("Feeding Room"); hunter.hunt(animal); }}

此時接口實現了多態。接口也成為Java中的多重繼承，在導出類中，如果是從一個非接口的類繼承，那只能繼承這一個類，其余的基元素都必須是接口，需要把所有的接口都置于implements關鍵字之后，用逗號將它們隔開。