我的观点是:

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

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

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

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

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

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

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

就我个人而言，我几乎从不需要编写抽象类。

大多数时候，我看到抽象类被(错误地)使用，这是因为抽象类的作者使用了“模板方法”模式。

“Template方法”的问题在于它几乎总是某种程度上是可重入的——“派生”类不仅知道它正在实现的基类的“抽象”方法，还知道基类的公共方法，即使大多数时候它不需要调用它们。

(过于简化的)例子:

abstract class QuickSorter
{
    public void Sort(object[] items)
    {
        // implementation code that somewhere along the way calls:
        bool less = compare(x,y);
        // ... more implementation code
    }
    abstract bool compare(object lhs, object rhs);
}

因此，在这里，该类的作者编写了一个泛型算法，并打算通过提供自己的“钩子”(在本例中是一个“比较”方法)来“专门化”它，以供人们使用。

所以预期的用法是这样的:

class NameSorter : QuickSorter
{
    public bool compare(object lhs, object rhs)
    {
        // etc.
    }
}

这样做的问题在于，你将两个概念过度地耦合在了一起:

比较两个项目的一种方法(哪个项目应该放在前面) 排序项目的方法(即快速排序vs归并排序等)

在上面的代码中，从理论上讲，“compare”方法的作者可以重新调用超类“Sort”方法…即使在实践中，他们永远不会想要或需要这样做。

为这种不必要的耦合付出的代价是，很难更改超类，而且在大多数OO语言中，不可能在运行时更改它。

另一种方法是使用“策略”设计模式:

interface IComparator
{
    bool compare(object lhs, object rhs);
}

class QuickSorter
{
    private readonly IComparator comparator;
    public QuickSorter(IComparator comparator)
    {
        this.comparator = comparator;
    }

    public void Sort(object[] items)
    {
        // usual code but call comparator.Compare();
    }
}

class NameComparator : IComparator
{
    bool compare(object lhs, object rhs)
    {
        // same code as before;
    }
}

现在请注意:我们所拥有的只是接口，以及这些接口的具体实现。在实践中，您实际上不需要任何其他东西来进行高级OO设计。

为了“隐藏”我们已经通过使用“QuickSort”类和“NameComparator”实现了“名称排序”的事实，我们仍然可以在某个地方写一个工厂方法:

ISorter CreateNameSorter()
{
    return new QuickSorter(new NameComparator());
}

任何时候你有一个抽象类，你都可以这样做…即使基类和派生类之间存在自然的可重入关系，将它们显式化通常也是值得的。

最后一个想法:我们上面所做的一切都是通过使用“QuickSort”函数和“NameComparison”函数来“组合”一个“NameSorting”函数……在函数式编程语言中，这种编程风格变得更加自然，代码更少。

如果我们有一个对所有派生类都相同的实现，那么此时最好使用抽象类而不是接口。当我们有一个接口时，我们可以将我们的实现移动到任何实现接口的类。在抽象类中，它避免了代码重复，并共享所有派生类的实现。接口允许开发松散耦合的系统，这有助于更好的测试。

答案因语言而异。例如，在Java中，一个类可以实现(继承)多个接口，但只能继承一个抽象类。所以接口给了你更多的灵活性。但在c++中却不是这样。

对我来说，在很多情况下我会选择接口。但在某些情况下，我更喜欢抽象类。

OO中的类通常指的是实现。当我想强制一些实现细节到子程序时，我使用抽象类，否则我就使用接口。

当然，抽象类不仅在强制实现方面有用，而且在许多相关类之间共享一些特定的细节方面也有用。

简单的回答是:抽象类允许您创建子类可以实现或覆盖的功能。接口只允许您定义功能，而不能实现它。虽然一个类只能扩展一个抽象类，但它可以利用多个接口。