假设你想要模拟当你试图睡觉时可能发生的烦恼。

接口前的模型

class Mosquito {
    void flyAroundYourHead(){}
}

class Neighbour{
    void startScreaming(){}
}

class LampJustOutsideYourWindow(){
    void shineJustThroughYourWindow() {}
}

正如你清楚地看到的，当你试图睡觉时，许多“事情”都可能令人讨厌。

使用没有接口的类

但是在使用这些类时，我们遇到了一个问题。他们毫无共同之处。您必须分别调用每个方法。

class TestAnnoyingThings{
    void testAnnoyingThinks(Mosquito mosquito, Neighbour neighbour, LampJustOutsideYourWindow lamp){
         if(mosquito != null){
             mosquito.flyAroundYourHead();
         }
         if(neighbour!= null){
             neighbour.startScreaming();
         }
         if(lamp!= null){
             lamp.shineJustThroughYourWindow();
         }
    }
}

带有接口的模型

为了克服这个问题，我们可以引入一个iterface

interface Annoying{
   public void annoy();

}

并在类中实现它

class Mosquito implements Annoying {
    void flyAroundYourHead(){}

    void annoy(){
        flyAroundYourHead();
    }
}

class Neighbour implements Annoying{
    void startScreaming(){}

    void annoy(){
        startScreaming();
    }
}

class LampJustOutsideYourWindow implements Annoying{
    void shineJustThroughYourWindow() {}

    void annoy(){
        shineJustThroughYourWindow();
    }
}

接口使用

这将使这些类的使用更容易

class TestAnnoyingThings{
    void testAnnoyingThinks(Annoying annoying){
        annoying.annoy();
    }
}

别太担心。很多开发人员很少需要编写接口。您将经常使用. net框架中可用的接口，但如果您觉得没有必要在短时间内编写一个接口，这也没什么好奇怪的。

我经常给别人的例子是，如果你有一个帆船职业和一个毒蛇职业。它们分别继承了Boat类和Car类。现在假设您需要遍历所有这些对象并调用它们的Drive()方法。你也可以编写如下代码:

if(myObject is Boat)
    ((Boat)myObject).Drive()
else
    if (myObject is Car)
        ((Car)myObject).Drive()

这样写会简单得多:

((IDrivable)myObject).Drive()

最简单的例子就是支付处理器。(Paypal, PDS等)。

假设您创建了一个具有ProcessACH和ProcessCreditCard方法的接口IPaymentProcessor。

现在可以实现一个具体的Paypal实现。让这些方法调用PayPal特定的函数。

如果你决定以后需要换到另一个提供商，你可以这样做。只需为新提供程序创建另一个具体实现。由于您所绑定的只是您的接口(契约)，因此您可以在不更改使用它的代码的情况下切换应用程序使用的接口。

我喜欢军队的比喻。

中士不在乎你是软件开发人员、音乐家还是律师。 你被当作士兵对待。

对于中士来说，不去操心与他一起工作的人的具体细节更容易， 把每个人都当作抽象的士兵(…如果他们表现得不像孩子，就要惩罚他们)。

人们像士兵一样行动的能力被称为多态性。

接口是帮助实现多态的软件结构。

为了实现简单，需要抽象细节，这就是你问题的答案。

Polymorphism, which etymologically means "many forms," is the ability to treat an object of any subclass of a base class as if it were an object of the base class. A base class has, therefore, many forms: the base class itself, and any of its subclasses. (..) This makes your code easier for you to write and easier for others to understand. It also makes your code extensible, because other subclasses could be added later to the family of types, and objects of those new subclasses would also work with the existing code.

当您希望能够对多个类型使用单个变量，但所有这些类型通过接口声明实现相同的方法时，Jimmy是正确的。然后你可以在接口类型变量上调用它们的main方法。

然而，使用接口还有第二个原因。当项目架构师和实现编码员是不同的人时，或者有几个实现编码员和一个项目经理。负责人可以编写一大堆接口，并查看系统的互操作，然后让开发人员用实现类填充接口。这是确保多人编写兼容类的最佳方法，而且他们可以并行地完成。

它解决了一个具体的问题:

你有a b c d四种不同类型。在你的代码中，你可以这样写:

a.Process();
b.Process();
c.Process();
d.Process();

为什么不让他们实现IProcessable呢

List<IProcessable> list;

foreach(IProcessable p in list)
    p.Process();

当你添加50种类型的类，它们都做同样的事情时，这种伸缩性会更好。

另一个具体问题是:

你有没有看过System.Linq.Enumerable?它定义了大量的扩展方法，可以对实现IEnumerable的任何类型进行操作。因为任何实现IEnumerable的东西基本上都在说“我支持无序foreach类型模式中的迭代”，所以你可以为任何可枚举类型定义复杂的行为(Count、Max、Where、Select等)。