Java 接口（interface）的作用与好处

首先提出两个问题：

一、明明可以在类中直接写所需的方法，为什么还要多写一个接口（或抽象类）？
二、抽象类和接口都差不多，在什么时候才选择使用接口？

一、抽象类 为了多态的实现

假设现在有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关键字之后，用逗号将它们隔开。

现在总结一下文章一开始提出的两个问题

一、明明可以在类中直接写所需的方法，为什么还要多写一个接口（或抽象类）？
       1. 减少代码的书写（上边分析的代码重载）
       2. 提高了代码的可维护性和扩展性。
       3. 在团队合作中，代码的规范性

二、抽象类和接口都差不多，在什么时候才选择使用接口？
       1. 在当前类族中不是必须的（例如Tuger需要而Rabbit不需要）的方法时
       2. 不同类族的多个类需要实现同样的方法时（接口）

接口还有许多没有总结的特点，例如泛型接口，总之学会规范使用接口，就会在将来的项目中，有着很大的帮助。