As several people have probably already answered, interfaces can be used to enforce certain behaviors between classes that will not implement those behaviors the same way. So by implementing an interface you are saying that your class has the behavior of the interface. The IAnimal interface would not be a typical interface because Dog, Cat, Bird, etc. classes are types of animals, and should probably extend it, which is a case of inheritance. Instead, an interface would be more like animal behavior in this case, such as IRunnable, IFlyable, ITrainable, etc.

接口有很多好处，其中一个关键就是可插拔性。例如，声明一个具有List参数的方法将允许传入实现List接口的任何东西，允许开发人员在以后删除和插入不同的列表，而不必重写大量代码。

您可能永远不会使用接口，但如果您正在从头开始设计一个项目，特别是某种类型的框架，您可能会想要熟悉它们。

我建议大家阅读Coad、Mayfield和Kern撰写的《Java设计》中关于接口的章节。它们比一般的介绍性文本解释得好一点。如果你不使用Java，你可以只阅读本章的开头，主要是一些概念。

In my experience the driving force to create interfaces didn't occur until I start doing unit testing with a mocking framework. It became abundantly clear that using interfaces was going to make mocking much easier (since the framework depended on the methods being virtual). Once I started I saw the value of abstracting away the interface to my class from the implementation. Even if I don't create an actual interface, I try now to make my methods virtual (providing an implicit interface that can be overridden).

我发现还有许多其他原因可以加强重构到接口的良好实践，但是单元测试/模拟的事情提供了最初的“顿悟时刻”的实践经验。

EDIT: To clarify, with unit testing and mocking I always have two implementations -- the real, concrete implementation and an alternate mock implementation used in testing. Once you have two implementations, the value of the interface becomes obvious -- deal with it in terms of the interface so you can replace the implementation at any time. In this case I'm replacing it with a mock interface. I know that I can do this without an actual interface if my class is constructed properly, but using an actual interface reinforces this and makes it cleaner (clearer to the reader). Without this impetus, I don't think I would have appreciated the value of interfaces since most of my classes only, ever have a single concrete implementation.

当相同功能的实现不同时使用接口。

当你需要共享一个公共的具体实现时，使用一个抽象/基类。

当您希望定义对象可以显示的行为时，通常会使用接口。

在. net世界中，一个很好的例子是IDisposable接口，它用于任何使用必须手动释放的系统资源的Microsoft类。它要求实现它的类具有Dispose()方法。

Dispose()方法也被VB的using语言构造调用。NET和c#，只适用于IDisposables)

请记住，您可以通过使用诸如TypeOf…之类的构造来检查对象是否实现了特定的接口。Is (VB.NET)， Is (c#)， instanceof (Java)，等等…

作为一个。net开发人员，你完全有可能一辈子都不编写自己的接口。毕竟，没有它们，我们也活了几十年，我们的语言仍然是图灵完备的。

我不能告诉你为什么你需要接口，但我可以给你一个我们在当前项目中使用它们的列表:

在我们的插件模型中，我们通过接口加载插件，并将该接口提供给插件编写者以使其遵循。 在我们的机间消息传递系统中，消息类都实现了一个特定的接口，并使用该接口“解包装”。 我们的配置管理系统定义了一个用于设置和检索配置设置的接口。 我们使用一个接口来避免讨厌的循环引用问题。(如果没有必要，就不要这样做。)

我想如果有一个规则，那就是当你想在一个is-a关系中对几个类进行分组，但你不想在基类中提供任何实现时使用接口。

假设你正在制作一款第一人称射击游戏。玩家有多种枪可供选择。

我们可以有一个接口Gun，它定义了函数shoot()。

我们需要不同的子类枪类，即霰弹枪狙击手等。

ShotGun implements Gun{
    public void shoot(){
       \\shotgun implementation of shoot.
    } 
}

Sniper implements Gun{
    public void shoot(){
       \\sniper implementation of shoot.
    } 
}

射击类

射手把所有的枪都装在他的盔甲里。让我们创建一个List来表示它。

List<Gun> listOfGuns = new ArrayList<Gun>();

射手在需要时使用switchGun()函数循环使用他的枪。

public void switchGun(){
    //code to cycle through the guns from the list of guns.
    currentGun = //the next gun in the list.
}

我们可以使用上面的函数设置当前的Gun，当调用fire()时，简单地调用shoot()函数。

public void fire(){
    currentGun.shoot();
}

shoot函数的行为将根据Gun接口的不同实现而有所不同。

结论

当一个类函数依赖于来自另一个类的函数时，创建一个接口，而另一个类根据实现的类的实例(对象)改变其行为。

例如，Shooter类的fire()函数期望枪械(Sniper, ShotGun)实现shoot()函数。 所以如果我们换枪开火。

shooter.switchGun();
shooter.fire();

我们已经改变了fire()函数的行为。