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

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

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

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

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

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

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

接口通常是没有逻辑的类，只有签名。而抽象类是具有逻辑的类。两者都支持作为接口的契约，所有方法都应该在子类中实现，但在抽象中只应该实现抽象方法。何时使用接口，何时抽象？为什么使用界面？

class Circle {

protected $radius;

public function __construct($radius)

{
    $this->radius = $radius
}

public function area()
{
    return 3.14159 * pow(2,$this->radius); // simply pie.r2 (square);
}

}

//Our area calculator class would look like

class Areacalculator {

$protected $circle;

public function __construct(Circle $circle)
{
    $this->circle = $circle;
}

public function areaCalculate()
{
    return $circle->area(); //returns the circle area now
}

}

我们只需要

$areacalculator = new Areacalculator(new Circle(7)); 

几天后，我们将需要矩形、正方形、四边形等区域。如果是这样，我们是否必须每次更改代码并检查实例是正方形、圆形还是矩形？现在OCP所说的是接口代码而不是实现。解决方案是：

Interface Shape {

public function area(); //Defining contract for the classes

}

Class Square implements Shape {

$protected length;

public function __construct($length) {
    //settter for length like we did on circle class
}

public function area()
{
    //return l square for area of square
}

Class Rectangle implements Shape {

$protected length;
$protected breath;

public function __construct($length,$breath) {
    //settter for length, breath like we did on circle,square class
}

public function area()
{
    //return l*b for area of rectangle
}

}

现在是面积计算器

class Areacalculator {

$protected $shape;

public function __construct(Shape $shape)
{
    $this->shape = $shape;
}

public function areaCalculate()
{
    return $shape->area(); //returns the circle area now
}

}

$areacalculator = new Areacalculator(new Square(1));
$areacalculator->areaCalculate();

$areacalculator = new Areacalculator(new Rectangle(1,2));
$areacalculator->;areaCalculate();

这不是更灵活吗？如果我们在没有接口的情况下进行编码，我们将检查每个形状冗余代码的实例。

现在什么时候使用抽象？

Abstract Animal {

public function breathe(){

//all animals breathe inhaling o2 and exhaling co2

}

public function hungry() {

//every animals do feel hungry 

}

abstract function communicate(); 
// different communication style some bark, some meow, human talks etc

}

现在，当一个人不需要那个类的实例，具有类似的逻辑，需要契约时，应该使用抽象。

一些重要的区别：

以表格的形式：

正如Joe在javapapers中所说：

1.主要区别在于Java接口的方法是隐式抽象的，不能有实现。Java抽象类可以具有实现默认行为的实例方法。2.Java接口中声明的变量默认为final。抽象类可以包含非最终变量。3.默认情况下，Java接口的成员是公共的。Java抽象类可以具有类成员的通常风格，受保护等。。4.Java接口应使用关键字“implements”实现；Java抽象类应该使用关键字“extends”进行扩展。5.接口只能扩展另一个Java接口，抽象类可以扩展另一Java类并实现多个Java接口。6.Java类可以实现多个接口，但只能扩展一个抽象类。7.接口是绝对抽象的，不能实例化；Java抽象类也不能实例化，但如果main（）存在。8.与java抽象类相比，java接口速度较慢，因为它需要额外的间接寻址。

接口

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

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

例如（伪代码）：

// 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__方法）。

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

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

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

同时，抽象类是：

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

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

我不想强调这些差异，这已经在很多答案中说过了（关于接口中变量的公共静态最终修饰符以及抽象类中受保护的私有方法的支持）

简单地说，我想说：

接口：通过多个不相关的对象实现合同

抽象类：在多个相关对象之间实现相同或不同的行为

来自Oracle文档

如果出现以下情况，请考虑使用抽象类：

您希望在几个密切相关的类之间共享代码。您希望扩展抽象类的类具有许多公共方法或字段，或者需要公共以外的访问修饰符（如protected和private）。您要声明非静态或非final字段。

如果出现以下情况，请考虑使用接口：

您希望不相关的类实现您的接口。例如，许多不相关的对象可以实现Serializable接口。您希望指定特定数据类型的行为，但不关心谁实现了它的行为。您希望利用类型的多重继承。

抽象类与具体类建立“是”关系。接口为类提供了“具有”功能。

如果您正在寻找Java作为编程语言，这里还有一些更新：

Java8通过提供默认方法特性，在一定程度上缩小了接口类和抽象类之间的差距。接口没有实现。方法现在不再有效。

有关详细信息，请参阅本文档页。

看看这个SE问题，了解代码示例，以便更好地理解。

我应该如何解释接口和抽象类之间的区别？