一些非编程示例可能帮助您了解接口在编程中的适当使用。

There's an interface between electrical devices and the electricity network - it's the set of conventions about the shape of the plugs and sockets and the voltages/currents across them. If you want to implement a new electrical device, as long as your plug follows the rules it will be able to get services from the network. This makes extensibility very easy and removes or lowers the costs of coordination: you don't have to notify the electricity provider about how your new device works and come to a separate agreement about how to plug your new device into the network.

各国都有标准的铁路轨距。这使得铺设铁轨的工程公司和建造在这些铁轨上运行的列车的工程公司之间实现了分工，并使铁路公司有可能在不重新设计整个系统的情况下更换和升级列车。

The service a business presents to a client can be described as an interface: a well defined interface emphasises the service and hides the means. When you put a letter in a mailbox, you expect the postal system to deliver the letter within a given time but you have no expectations about how the letter is delivered: you don't need to know, and the postal service has the flexibility to choose the means of delivery that best meets the requirements and current circumstances. An exception to this is the ability of customers to choose airmail - that's not the kind of interface a modern computer programmer would have designed, since it reveals too much of the implementation.

来自自然的例子:我不太喜欢eats()， makesSound()， moves()等例子。它们确实描述了行为，这是正确的，但它们没有描述交互以及它们是如何被启用的。在自然界中，使相互作用成为可能的界面的一个明显的例子是与繁殖有关的，例如一朵花为蜜蜂提供了一个特定的界面，以便授粉能够发生。

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.

使用接口有很多目的。

Use in polymorphic behavior. Where you want to call specific methods of a child class with an inteface having a reference to the child class. Having a contract with classes to implement all of the methods where it is necessary, like most common use is with COM objects , where a wrapper class is generated on a DLL which inherits the interface; these methods are called behind the scenes, and you just need to implement them but with the same structure as defined in the COM DLL which you can only know through the interface that they expose. To reduce memory usage by loading specific methods in a class. Like if you have three business objects and they are implemented in a single class, you can use three interfaces.

例如IUser, IOrder, IOrderItem

public interface IUser()
{

void AddUser(string name ,string fname);

}

// Same for IOrder and IOrderItem
//


public class  BusinessLayer: IUser, IOrder, IOrderItem

{    
    public void AddUser(string name ,string fname)
    {
        // Do stuffs here.
    }

    // All methods from all interfaces must be implemented.

}

如果你只想添加一个用户，可以这样做:

IUser user = new (IUser)BusinessLayer();

// It will load  all methods into memory which are declared in the IUser interface.

user.AddUser();

扩展一下Larsenal所说的。接口是所有实现类都必须遵循的契约。因此，您可以使用一种称为契约编程的技术。这允许您的软件变得独立于实现。

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

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

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

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

与任何为系统增加灵活性的编程技术一样，接口也增加了一定程度的复杂性。它们通常都很好，而且你可以在任何地方使用它(你可以为你的所有类创建一个接口)——但是这样做，你会创建一个更复杂的系统，更难维护。

像往常一样，这里有一个权衡:灵活性胜过可维护性。哪个更重要?没有答案——这取决于项目本身。但是请记住，每个软件都需要维护……

所以我的建议是:在真正需要接口之前不要使用它们。(使用Visual Studio，你可以在2秒内从现有的类中提取一个接口——所以不要着急。)

话虽如此，你什么时候需要创建一个接口呢?

当我重构一个突然需要处理两个或多个类似类的方法时，我就会这样做。然后创建一个接口，将该接口分配给两个(或多个)类似的类，并更改方法参数类型(将类类型替换为接口类型)。

它是有效的:o)

一个例外:当我模拟对象时，接口更容易使用。我经常为此创建接口。

PS:当我写“接口”时，我的意思是:“任何基类的接口”，包括纯接口类。请注意，抽象类通常比纯接口更好，因为您可以向它们添加逻辑。

此致,Sylvain。