总结起来最简单的方法是：

完全抽象，除了默认和静态方法；虽然它有默认和静态方法的定义（方法签名+实现），但它只有其他方法的声明（方法签名）。受比类更宽松的规则约束（类可以实现多个接口，接口可以从多个接口继承）。所有变量都是隐式常量，无论是否指定为公共静态final。所有成员都是隐式公共的，无论是否指定为公共成员。通常用于保证实现类将具有指定的特性和/或与实现相同接口的任何其他类兼容。

同时，抽象类是：

从完全抽象到完全实现，具有一个或多个抽象方法的倾向。可以包含声明和定义，声明标记为抽象。一个完整的类，并且受制于管理其他类的规则（只能从一个类继承），条件是它不能实例化（因为不能保证它完全实现）。可以具有非常量成员变量。可以实现成员访问控制，将成员限制为受保护、私有或私有包（未指定）。通常用于提供可由多个子类共享的尽可能多的实现，或者提供程序员能够提供的尽可能的实现。

或者，如果我们想将其归结为一句话：接口是实现类所拥有的，而抽象类是子类所拥有。

抽象类与接口的主题主要是语义。

抽象类在不同的编程语言中通常充当接口的超集，除了一点，即可以实现多个接口，但只能继承一个类。

接口定义了某件事情必须能够做的事情；类似于合同，但不提供其实现。

抽象类定义了什么是什么，它通常托管子类之间的共享代码。

例如，格式化程序应该能够格式化（）某些内容。描述这种情况的常见语义是创建一个接口IFormatter，该接口带有一个format（）声明，其作用类似于一个契约。但是IFormatter并不描述什么是什么，而是描述它应该能够做什么。在本例中，我们创建一个抽象类。。。因此，我们创建了一个实现接口的抽象类Formatter。这是一个非常描述性的代码，因为我们现在知道我们有一个格式化程序，我们现在知道每个格式化程序必须能够做什么。

还有一个非常重要的主题是文档（至少对某些人来说…）。在您的文档中，您可能希望在子类中解释Formatter实际上是什么。有一个抽象类Formatter非常方便，您可以链接到子类中的文档。这是非常方便和通用的。另一方面，如果您没有抽象类Formatter，而只有接口IFormatter，则必须在每个子类中解释Formatter实际上是什么，因为接口是一个契约，你不会在接口的文档中描述Formatter实际上是什么-至少这不是常见的事情，你会打破大多数开发人员认为正确的语义。

注意：使抽象类实现接口是一种非常常见的模式。

接口

接口是一个契约：编写接口的人说，“嘿，我接受这样的东西”，而使用接口的人则说“好的，我编写的类是这样的”。

接口是一个空壳。只有方法的签名，这意味着方法没有主体。接口无法执行任何操作。这只是一种模式。

例如（伪代码）：

// I say all motor vehicles should look like this:
interface MotorVehicle
{
    void run();

    int getFuel();
}

// My team mate complies and writes vehicle looking that way
class Car implements MotorVehicle
{

    int fuel;

    void run()
    {
        print("Wrroooooooom");
    }


    int getFuel()
    {
        return this.fuel;
    }
}

实现一个接口只消耗很少的CPU，因为它不是一个类，只是一堆名称，因此不需要进行任何昂贵的查找。在重要的时候，比如在嵌入式设备中，这是非常棒的。

抽象类

与接口不同，抽象类是类。它们的使用成本更高，因为从它们继承时需要进行查找。

抽象类看起来很像接口，但它们有更多：您可以为它们定义行为。这更像是一个人说，“这些课程应该看起来像那样，而且它们有共同点，所以填空吧！”。

例如：

// I say all motor vehicles should look like this:
abstract class MotorVehicle
{

    int fuel;

    // They ALL have fuel, so lets implement this for everybody.
    int getFuel()
    {
         return this.fuel;
    }

    // That can be very different, force them to provide their
    // own implementation.
    abstract void run();
}

// My teammate complies and writes vehicle looking that way
class Car extends MotorVehicle
{
    void run()
    {
        print("Wrroooooooom");
    }
}

实施

虽然抽象类和接口被认为是不同的概念，但实现有时会使该语句不真实。有时，他们甚至不是你想象的那样。

在Java中，这个规则是强制执行的，而在PHP中，接口是没有声明方法的抽象类。

在Python中，抽象类更多地是一种编程技巧，您可以从ABC模块中获得，并且实际上使用元类，因此使用类。接口与这种语言中的duck类型更为相关，它混合了约定和调用描述符的特殊方法（__method__方法）。

与编程一样，还有另一种语言的理论、实践和实践：-）

接口与抽象类的比较是错误的。应该有另外两个比较：1）接口与类，2）抽象与最终类。

接口与类

接口是两个对象之间的契约。例如，我是一名邮递员，而你是一个要递送的包裹。我希望你知道你的送货地址。当有人给我一个包裹时，它必须知道它的送货地址：

interface Package {
  String address();
}

类是一组遵守契约的对象。例如，我是“箱子”小组的一名箱子，我遵守邮递员要求的合同。同时，我遵守其他合同：

class Box implements Package, Property {
  @Override
  String address() {
    return "5th Street, New York, NY";
  }
  @Override
  Human owner() {
    // this method is part of another contract
  }
}

摘要与最终

抽象类是一组不完整的对象。它们不能使用，因为它们缺少一些部件。例如，我是一个抽象的GPS感知框-我知道如何检查我在地图上的位置：

abstract class GpsBox implements Package {
  @Override
  public abstract String address();
  protected Coordinates whereAmI() {
    // connect to GPS and return my current position
  }
}

这个类如果被另一个类继承/扩展，可能非常有用。但就其本身而言，它是无用的，因为它不能有对象。抽象类可以是最终类的构建元素。

Final类是一组完整的对象，可以使用，但不能修改。他们确切地知道如何工作和做什么。例如，我是一个盒子，它总是在构建过程中到达指定的地址：

final class DirectBox implements Package {
  private final String to;
  public DirectBox(String addr) {
    this.to = addr;
  }
  @Override
  public String address() {
    return this.to;
  }
}

在大多数语言中，如Java或C++，可能只有一个类，既不是抽象类也不是最终类。这样的类可以继承并实例化。不过，我认为这并不严格符合面向对象的范例。

同样，将接口与抽象类进行比较是不正确的。

我想再加一个有意义的区别。例如，您有一个包含数千行代码的框架。现在，如果您想使用方法enhanceUI（）在整个代码中添加新特性，那么最好在抽象类中添加该方法，而不是在接口中添加。因为，如果在接口中添加此方法，那么应该在所有已实现的类中实现它，但如果在抽象类中添加方法则不是这样。

界面：转弯（左转，右转）

抽象类：轮子。

类别：方向盘，衍生自方向盘，暴露接口转向

一个是对可以在各种各样的事物中提供的行为进行分类，另一个是为事物本体建模。