接口和基类表示两种不同形式的关系。

继承（基类）表示“is-a”关系。例如，狗或猫是宠物。这种关系始终代表着班级的（单一）目的（结合“单一责任原则”）。

另一方面，接口表示类的其他特性。我将其称为“是”关系，如“Foo是一次性的”，因此C#中的IDisposable接口。

让我们以Dog和Cat类为例，使用C#进行演示：

狗和猫都是动物，特别是四足哺乳动物（动物太普通了）。让我们假设您有一个抽象类Mammal，用于这两个类：

public abstract class Mammal

此基类可能具有默认方法，例如：

喂养朋友

所有这些都是在两个物种之间或多或少具有相同实现的行为。要定义此项，您需要：

public class Dog : Mammal
public class Cat : Mammal

现在让我们假设还有其他哺乳动物，我们通常会在动物园里看到：

public class Giraffe : Mammal
public class Rhinoceros : Mammal
public class Hippopotamus : Mammal

这仍然有效，因为Feed（）和Mate（）功能的核心仍然相同。

然而，长颈鹿、犀牛和河马并不是你可以用来做宠物的动物。这就是界面将有用的地方：

public interface IPettable
{
    IList<Trick> Tricks{get; set;}
    void Bathe();
    void Train(Trick t);
}

上述合同的执行在猫和狗之间是不同的；将它们的实现放在抽象类中继承将是一个坏主意。

狗和猫的定义现在应该如下：

public class Dog : Mammal, IPettable
public class Cat : Mammal, IPettable

理论上，您可以从更高的基类重写它们，但本质上，接口允许您只将所需的内容添加到类中，而不需要继承。

因此，由于您通常只能从一个抽象类继承（在大多数静态类型的OO语言中，即……例外包括C++），但能够实现多个接口，因此它允许您严格按照需要构造对象。

一个重要的区别是，只能继承一个基类，但可以实现多个接口。因此，如果您绝对确定不需要同时继承不同的基类，那么只需要使用基类。此外，如果你发现你的接口越来越大，那么你应该开始把它分成几个逻辑块来定义独立的功能，因为没有规则规定你的类不能实现所有的功能（或者你可以定义一个不同的接口来继承所有的功能）。

资料来源：http://jasonroell.com/2014/12/09/interfaces-vs-abstract-classes-what-should-you-use/

C#是一种奇妙的语言，在过去的14年中不断成熟和发展。这对我们开发人员来说很好，因为一种成熟的语言为我们提供了大量的语言特性，供我们使用。

然而，权力大了，责任大了。其中一些功能可能被误用，或者有时很难理解为什么您会选择使用一个功能而不是另一个功能。多年来，我看到许多开发人员都在纠结于一个特性，那就是什么时候选择使用接口或者选择使用抽象类。两者都有各自的优点和缺点，以及使用它们的正确时间和地点。但我们如何决定？？？

两者都提供了类型之间公共功能的重用。最明显的区别是，接口不提供其功能的实现，而抽象类允许您实现一些“基本”或“默认”行为，然后可以在必要时使用类派生类型“覆盖”此默认行为。

这一切都很好，并且提供了代码的重用，并且遵循了软件开发的DRY（不要重复自己）原则。当你有一种“是”的关系时，抽象类很好用。

例如：金毛寻回犬是一种狗。贵宾犬也是。它们都会吠叫，就像所有的狗一样。然而，您可能需要指出，贵宾犬公园与“默认”狗叫有明显不同。因此，您可以执行以下操作：

public abstract class Dog
{
      public virtual void Bark()
      {
        Console.WriteLine("Base Class implementation of Bark");
      }
}

public class GoldenRetriever : Dog
{
   // the Bark method is inherited from the Dog class
}

public class Poodle : Dog
{
  // here we are overriding the base functionality of Bark with our new implementation
  // specific to the Poodle class
  public override void Bark()
  {
     Console.WriteLine("Poodle's implementation of Bark");
  }
}

// Add a list of dogs to a collection and call the bark method.

void Main()
{
    var poodle = new Poodle();
    var goldenRetriever = new GoldenRetriever();

    var dogs = new List<Dog>();
    dogs.Add(poodle);
    dogs.Add(goldenRetriever);

    foreach (var dog in dogs)
    {
       dog.Bark();
    }
}

// Output will be:
// Poodle's implementation of Bark
// Base Class implementation of Bark

// 

正如您所看到的，这将是一种保持代码干燥的好方法，并允许在任何类型只能依赖默认Bark而不是特殊情况实现时调用基类实现。GoldenRetriever、Boxer、Lab等类都可以免费继承“默认”（低音类）Bark，因为它们实现了Dog抽象类。

但我相信你已经知道了。

您来到这里是因为您想了解为什么您可能希望选择一个接口而不是抽象类，反之亦然。嗯，您可能希望选择接口而不是抽象类的一个原因是，当您没有或希望阻止默认实现时。这通常是因为实现接口的类型与“是”关系无关。事实上，除了每种类型“能够”或“有能力”做某事或拥有某事这一事实之外，它们根本不必是相关的。

那到底是什么意思？嗯，举个例子：人不是鸭子……鸭子也不是人。很明显。然而，鸭子和人类都有游泳的“能力”（考虑到人类在一年级通过了游泳课程：）。此外，由于鸭子不是人，反之亦然，这不是“是一种”关系，而是“能够”关系，我们可以使用一个界面来说明：

// Create ISwimable interface
public interface ISwimable
{
      public void Swim();
}

// Have Human implement ISwimable Interface
public class Human : ISwimable

     public void Swim()
     {
        //Human's implementation of Swim
        Console.WriteLine("I'm a human swimming!");
     }

// Have Duck implement ISwimable interface
public class Duck: ISwimable
{
     public void Swim()
     {
          // Duck's implementation of Swim
          Console.WriteLine("Quack! Quack! I'm a Duck swimming!")
     }
}

//Now they can both be used in places where you just need an object that has the ability "to swim"

public void ShowHowYouSwim(ISwimable somethingThatCanSwim)
{
     somethingThatCanSwim.Swim();
}

public void Main()
{
      var human = new Human();
      var duck = new Duck();

      var listOfThingsThatCanSwim = new List<ISwimable>();

      listOfThingsThatCanSwim.Add(duck);
      listOfThingsThatCanSwim.Add(human);

      foreach (var something in listOfThingsThatCanSwim)
      {
           ShowHowYouSwim(something);
      }
}

 // So at runtime the correct implementation of something.Swim() will be called
 // Output:
 // Quack! Quack! I'm a Duck swimming!
 // I'm a human swimming!

使用上面的代码这样的接口将允许您将对象传递给“能够”执行某些操作的方法。代码不在乎它是如何做到的……它只知道它可以对该对象调用Swim方法，并且该对象将根据其类型知道在运行时采取的行为。

再次，这有助于代码保持干燥，这样您就不必编写多个调用对象的方法来预成型相同的核心函数（ShowHowHumanSwims（人类）、ShowHowDuckSwims（鸭子）等）

在这里使用接口允许调用方法不必担心行为是什么类型或如何实现的。它只是知道，给定接口，每个对象都必须实现Swim方法，因此在自己的代码中调用它是安全的，并允许在自己的类中处理Swim方法的行为。

摘要：

因此，我的主要经验法则是，当你想为一个类层次结构或/和你正在处理的类或类型实现一个“默认”功能时，使用一个抽象类。

另一方面，如果你没有“是一种”关系，但类型共享“能力”来做某事或拥有某事（例如，鸭子“不是”人类“。然而，鸭子和人类共享“游泳能力”），则使用界面。

抽象类和接口之间需要注意的另一个区别是，一个类可以实现一对多接口，但一个类只能从一个抽象类（或任何类）继承。是的，您可以嵌套类并具有继承层次结构（许多程序都这样做，也应该这样做），但不能在一个派生类定义中继承两个类（这一规则适用于C#。在其他一些语言中，您可以这样做，通常是因为这些语言中缺少接口）。

还请记住，使用接口时要遵守接口隔离原则（ISP）。ISP表示，不应强迫任何客户端依赖它不使用的方法。因此，接口应该专注于特定的任务，并且通常非常小（例如IDisposable、IComparable）。

另一个提示是，如果您正在开发小而简洁的功能，请使用接口。如果要设计大型功能单元，请使用抽象类。

希望这能为一些人扫清障碍！

此外，如果你能想出任何更好的例子或想指出什么，请在下面的评论中这样做！

另一个要记住的选项是使用“has-a”关系，也就是“以”或“组合的方式实现”。有时这是一种比使用“is-a”继承更干净、更灵活的结构方式。

从逻辑上说，狗和猫都“拥有”一只宠物可能不太合理，但它避免了常见的多重继承陷阱：

public class Pet
{
    void Bathe();
    void Train(Trick t);
}

public class Dog
{
    private Pet pet;

    public void Bathe() { pet.Bathe(); }
    public void Train(Trick t) { pet.Train(t); }
}

public class Cat
{
    private Pet pet;

    public void Bathe() { pet.Bathe(); }
    public void Train(Trick t) { pet.Train(t); }
}

是的，这个例子表明，在以这种方式做事时存在大量的代码重复和缺乏优雅。但我们也应该意识到，这有助于保持狗和猫与宠物类的分离（因为狗和猫不能访问宠物的私人成员），并为狗和猫从其他东西（可能是哺乳动物类）继承留下了空间。

当不需要私人访问并且您不需要使用通用的宠物参考/指针来参考狗和猫时，合成是最好的。接口为您提供了通用的引用功能，可以帮助减少代码的冗长，但当组织不好时，它们也会使事情变得模糊。当您需要私人成员访问时，继承是有用的，在使用它时，您将致力于将您的狗和猫类与您的宠物类高度耦合，这是一个巨大的成本。

在继承、组合和接口之间，没有一种方法总是正确的，考虑如何协调地使用这三种选项是有帮助的。在这三个选项中，继承通常是最不常用的选项。

当我第一次开始学习面向对象编程时，我犯了一个简单的、可能也是常见的错误，即使用继承来共享公共行为——即使这种行为对对象的本质来说并不重要。

为了进一步建立这个问题中经常使用的例子，有很多东西都是可拍的——女朋友、汽车、毛毯所以我可能有一个Petable类提供了这种常见的行为，以及从中继承的各种类。

然而，可拍不是这些物体的本质的一部分。还有很多更重要的概念对他们的天性至关重要——女朋友是人，汽车是陆地车辆，猫是哺乳动物。。。

行为应该首先被分配给接口（包括类的默认接口），并且只有当它们（a）对于作为更大类的子集的一大群类来说是公共的时，才应该被提升为基类——在相同的意义上，“猫”和“人”是“哺乳动物”的子集。

问题是，当你比我一开始更了解面向对象设计之后，你通常会自动完成这项工作，甚至不用考虑它。因此，“代码到接口，而不是抽象类”这句话的真实性变得如此明显，你很难相信任何人都会不厌其烦地说出它，并开始尝试将其他含义解读到其中。

我想补充的另一点是，如果一个类是纯抽象的-没有非抽象的、非继承的成员或方法暴露给子级、父级或客户端-那么为什么它是一个类？它可以被替换，在某些情况下被接口替换，在其他情况下被Null替换。