我的观点是:

接口基本上定义了一个契约，任何实现类都必须遵守(实现接口成员)。它不包含任何代码。

另一方面，抽象类可以包含代码，并且可能有一些标记为抽象的方法，继承类必须实现这些方法。

我很少使用抽象类的情况是，当我有一些默认功能时，继承类可能对重写不感兴趣，比如一个抽象基类，一些专门的类继承自它。

示例(非常基本的一个!):考虑一个名为Customer的基类，它具有抽象方法，如CalculatePayment()， CalculateRewardPoints()和一些非抽象方法，如GetName()， SavePaymentDetails()。

像RegularCustomer和GoldCustomer这样的专门的类将继承自Customer基类，并实现它们自己的CalculatePayment()和CalculateRewardPoints()方法逻辑，但是重用GetName()和SavePaymentDetails()方法。

您可以向抽象类(即非抽象方法)添加更多功能，而不会影响使用旧版本的子类。然而，向接口添加方法会影响实现它的所有类，因为它们现在需要实现新添加的接口成员。

具有所有抽象成员的抽象类类似于接口。

好吧，我自己刚刚“grokup”了这个——这是外行的术语(如果我错了，请随意纠正我)——我知道这个话题太老了，但其他人可能有一天会偶然发现它……

抽象类允许你创建一个蓝图，并允许你额外构造(实现)属性和方法，你希望它的所有后代都拥有。

另一方面，接口只允许您声明希望在实现它的所有类中存在具有给定名称的属性和/或方法——但不指定应该如何实现它。同样，一个类可以实现许多接口，但只能扩展一个抽象类。界面更像是一种高级架构工具(如果你开始掌握设计模式，这一点就会变得更清楚)——抽象则同时涉足这两个阵营，也可以执行一些繁琐的工作。

为什么使用其中一种而不是另一种呢?前者允许对后代进行更具体的定义，而后者允许更大的多态性。最后一点对最终用户/编码器很重要，他们可以利用这些信息以各种组合/形状来实现A.P.I(界面)，以满足他们的需求。

我认为这对我来说是一个“顿悟”的时刻——少从作者的角度来考虑接口，多从后面加入到项目中实现或扩展API的编码器的角度来考虑接口。

如果您想提供一些基本实现，请使用抽象类。

我为此写了一篇文章:

抽象类和接口

总结:

当我们谈论抽象类时，我们是在定义对象类型的特征;指定对象是什么。

当我们谈论接口和定义我们承诺提供的功能时，我们谈论的是建立一个关于对象可以做什么的契约。

我认为最简洁的说法是:

共享属性=>抽象类。 共享功能=>接口。

更简单地说……

抽象类示例:

public abstract class BaseAnimal
{
    public int NumberOfLegs { get; set; }

    protected BaseAnimal(int numberOfLegs)
    {
        NumberOfLegs = numberOfLegs;
    }
}

public class Dog : BaseAnimal
{
    public Dog() : base(4) { }
}

public class Human : BaseAnimal 
{
    public Human() : base(2) { }
}

由于动物有一个共同的属性——在这种情况下是腿的数量——创建一个包含这个共同属性的抽象类是有意义的。这也允许我们编写操作该属性的通用代码。例如:

public static int CountAllLegs(List<BaseAnimal> animals)
{
    int legCount = 0;
    foreach (BaseAnimal animal in animals)
    {
        legCount += animal.NumberOfLegs;
    }
    return legCount;
}

接口的例子:

public interface IMakeSound
{
    void MakeSound();
}

public class Car : IMakeSound
{
    public void MakeSound() => Console.WriteLine("Vroom!");
}

public class Vuvuzela : IMakeSound
{
    public void MakeSound() => Console.WriteLine("VZZZZZZZZZZZZZ!");        
}

这里要注意的是，呜呜祖拉和汽车是完全不同的东西，但它们有共同的功能:发出声音。因此，接口在这里是有意义的。此外，它将允许程序员将发出声音的东西分组在一个公共界面下——在本例中是IMakeSound。通过这种设计，你可以编写以下代码:

List<IMakeSound> soundMakers = new List<ImakeSound>();
soundMakers.Add(new Car());
soundMakers.Add(new Vuvuzela());
soundMakers.Add(new Car());
soundMakers.Add(new Vuvuzela());
soundMakers.Add(new Vuvuzela());

foreach (IMakeSound soundMaker in soundMakers)
{
    soundMaker.MakeSound();
}

你知道那会输出什么吗?

最后，您可以将两者结合起来。

结合例子:

public interface IMakeSound
{
    void MakeSound();
}

public abstract class BaseAnimal : IMakeSound
{
    public int NumberOfLegs { get; set; }

    protected BaseAnimal(int numberOfLegs)
    {
        NumberOfLegs = numberOfLegs;
    }

    public abstract void MakeSound();
}

public class Cat : BaseAnimal
{
    public Cat() : base(4) { }

    public override void MakeSound() => Console.WriteLine("Meow!");
}

public class Human : BaseAnimal 
{
    public Human() : base(2) { }

    public override void MakeSound() => Console.WriteLine("Hello, world!");
}

这里，我们要求所有的BaseAnimals发出声音，但是我们还不知道它的实现。在这种情况下，我们可以抽象接口实现并将其实现委托给它的子类。

最后一点，还记得在抽象类示例中我们如何操作不同对象的共享属性，以及在接口示例中我们如何调用不同对象的共享功能吗?在最后一个例子中，我们可以两者都做。

如果下列语句适用于您的情况，请考虑使用抽象类:

您希望在几个密切相关的类之间共享代码。 您希望扩展抽象类的类具有许多公共方法或字段，或者需要除public以外的访问修饰符(例如protected和private)。 您希望声明非静态或非final字段。这使您能够定义可以访问和修改其所属对象状态的方法。

如果这些语句适用于您的情况，请考虑使用接口:

您希望不相关的类实现您的接口。例如，Comparable和Cloneable接口是由许多不相关的类实现的。 您希望指定特定数据类型的行为，但不关心由谁实现其行为。 您希望利用多个继承。

源