可以在这里找到解释：http://www.developer.com/lang/php/article.php/3604111/PHP-5-OOP-Interfaces-Abstract-Classes-and-the-Adapter-Pattern.htm

抽象类是一个类，它是仅部分由程序员。它可能包含一个或多个抽象方法抽象方法只是一个函数定义用来告诉程序员方法必须在子进程中实现类。

接口类似于抽象类；确实接口占据了与类和抽象相同的命名空间因为这个原因，你不能定义一个同名的接口作为一个类。接口是一个完全抽象类；它的任何方法被实现，而不是一个类从它的子类，据说实现该接口。

无论如何，我发现接口的这种解释有点令人困惑。更常见的定义是：接口定义了实现类必须履行的契约。接口定义由公共成员的签名组成，没有任何实现代码。

接口

接口是合同：编写接口的人说“嘿，我接受这样的事情”，使用接口的人说“好吧，我写的类看起来是这样的”。

接口是一个空壳。只有方法的签名，这意味着方法没有主体。接口什么也做不了。这只是一个模式。

例如（伪代码）：

// I say all motor vehicles should look like this:interface MotorVehicle{void run();
int getFuel();}
// My team mate complies and writes vehicle looking that wayclass 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 wayclass Car extends MotorVehicle{void run(){print("Wrroooooooom");}}

实施

虽然抽象类和接口应该是不同的概念，但实现有时会使该声明不真实。有时，它们甚至不是你想象的那样。

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

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

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

不是原始问题的答案，但是一旦你有了它们之间差异的答案，你将进入何时使用每个困境：什么时候使用接口或抽象类？什么时候同时使用两者？

我对OOP的了解有限，但是直到现在，将接口视为语法中的形容词的等价物一直对我有效（如果这种方法是假的，请纠正我！）。例如，接口名称就像你可以赋予类的属性或功能，一个类可以有许多属性或功能：ISerializable、ICountable、IList、ICacheable、IHappy、…

抽象类和接口之间的关键技术差异是：

• 抽象类可以有常量、成员、方法存根（没有主体的方法）和定义的方法，而接口只能有常量和方法存根。

• 抽象类的方法和成员可以用任何可见性定义，而接口的所有方法都必须定义为public（默认情况下它们是公共定义的）。

• 继承抽象类时，具体子类必须定义抽象方法，而抽象类可以扩展另一个抽象类，并且不必定义父类的抽象方法。

• 类似地，扩展另一个接口的接口不负责从父接口实现方法。这是因为接口不能定义任何实现。

• 子类只能扩展单个类（抽象或具体），而接口可以扩展或类可以实现多个其他接口。

• 子类可以定义具有相同或更少限制性可见性的抽象方法，而实现接口的类必须定义具有完全相同可见性（公共）的方法。

让我们再次研究这个问题：

首先要让你知道的是，1/1和1*1的结果是一样的，但这并不意味着乘法和除法是一样的。显然，它们有一些很好的关系，但请注意，你们两个是不同的。

我将指出主要的区别，其余的已经解释过了：

抽象类对于建模类层次结构很有用。乍一看任何需求，我们都部分清楚完全要构建什么，但我们知道建什么。所以你的抽象类就是你的基类。

接口对于让其他层次结构或类知道我能做什么很有用。当你说我能做某事时，你必须有这种能力。接口会将其标记为类实现相同功能的强制性。

当您想在继承层次结构中提供多态行为时，请使用抽象类。

当您想要完全不相关的类的多态行为时，请使用接口。

一些重要的区别：

以桌子的形式：

如来自javap的Joe：

1.主要区别在于Java接口的方法是隐式抽象的，不能有实现有实现默认行为的实例方法。

2.Java接口中声明的变量默认为Final。抽象类可以包含非Final变量。

3.默认情况下，Java接口的成员是公共的。Java抽象类可以具有类成员的常见风格，例如Private、保护等等

4.Java接口应该使用关键字“implements”来实现；Java抽象类应该使用关键字“扩展”来扩展。

一个接口只能扩展另一个Java接口，抽象类可以扩展另一个Java类并实现多个Java接口。

6.一个Java类可以实现多个接口，但只能扩展一个抽象类。

7.接口是绝对抽象的，不能被实例化；一个Java抽象类也不能被实例化，但可以被调用，如果main（）存在。

8.与java抽象类相比，java接口很慢，因为它需要额外的间接。

在一个接口中，所有的方法都必须只是定义，而不应该实现单个方法。

但是在抽象类中必须有一个只有定义的抽象方法，但其他方法也可以在抽象类中实现。

继承用于两个目的：

• 允许对象将父类型数据成员和方法实现视为自己的。

• 允许期望对超类型对象的引用的代码使用对一种类型的对象的引用。

在支持广义多重继承的语言/框架中，通常不需要将类型分类为“接口”或“抽象类”。然而，流行的语言和框架允许一种类型将另一种类型的数据成员或方法实现视为自己的，即使它们允许一种类型可替换任意数量的其他类型。

抽象类可以有数据成员和方法实现，但只能被不从任何其他类继承的类继承。接口对实现它们的类型几乎没有限制，但不能包括任何数据成员或方法实现。

有些时候，类型可以替代许多不同的东西；还有一些时候，对象将父类型数据成员和方法实现视为自己的东西是有用的。区分接口和抽象类允许在最相关的情况下使用这些能力。

接口只包含功能的定义/签名，如果我们有一些通用的功能和通用签名，那么我们需要使用一个抽象类。通过使用抽象类，我们可以同时提供行为和功能。另一个继承抽象类的开发人员可以轻松使用这个功能，因为他们只需要填写空白。

图片来源：

http://www.dotnetbull.com/2011/11/difference-between-abstract-class-and.html

http://www.dotnetbull.com/2011/11/what-is-abstract-class-in-c-net.htmlhttp://www.dotnetbull.com/2011/11/what-is-interface-in-c-net.html

我正在建造一座300层的大楼

建筑的蓝图接口

• 例如，Servlet（I）

建筑高达200层-部分完成---抽象

• 部分实现，例如泛型和HTTP servlet

建筑施工完成-具体

• 完全实现，例如，自己的servlet

接口

• 我们对实现一无所知，只知道需求。我们可以去一个接口。
• 默认情况下，每个方法都是公共和抽象的
• 它是一个100%纯抽象类
• 如果我们声明公共，我们就不能声明私有和受保护
• 如果我们声明抽象，我们就不能声明Final、静态、同步、严格的fp和本机
• 每个接口都有public、静态和Final
• 序列化和瞬态不适用，因为我们无法为in接口创建实例
• 非易失性，因为它是最终的
• 每个变量都是静态的
• 当我们在接口中声明变量时，我们需要在声明时初始化变量
• 不允许实例和静态块

摘要

• 部分执行
• 它有一个抽象的方法。一个附加，它使用具体
• 对抽象类方法修饰符没有限制
• 对抽象类变量修饰符没有限制
• 除了抽象，我们不能声明其他修饰符
• 初始化变量没有限制

摘自DurgaJobs网站

其实很简单。

您可以将接口视为只允许有抽象方法而不允许有其他方法的类。

因此，接口只能“声明”而不能定义您希望类具有的行为。

抽象类允许您声明（使用抽象方法）以及定义（使用完整方法实现）您希望类具有的行为。

常规类只允许您定义，而不是声明您希望类具有的行为/操作。

最后一件事，

在Java，您可以实现多个接口，但只能扩展一个（抽象类或类）。

这意味着定义行为的继承被限制为每个类只允许一个……即如果你想要一个封装了类A、B和C行为的类，你需要执行以下操作：类A扩展B，类C扩展A……它有点绕来绕去的方式有多个继承……

接口另一方面，你可以简单地做：接口C实现A，B

所以实际上Java只在“声明的行为”即接口中支持多重继承，并且只支持具有定义行为的单一继承……除非你按照我描述的方式进行……

希望这有道理。

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

接口与类

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

interface Package {String address();}

类是一组遵守契约的对象。例如，我是“Box”组中的一个盒子，我遵守邮递员要求的契约。同时我遵守其他契约：

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

抽象vs最终

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

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

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

最后一堂课是一组完整的对象，可以使用，但不能修改。他们确切地知道如何工作和做什么。例如，我是一个Box，在构建过程中总是去指定的地址：

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

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

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

唯一的区别是一个可以参与多重继承，而另一个不能。

接口的定义随着时间的推移而改变。你认为接口只有方法声明和契约吗？Java8之后的静态最终变量和默认定义呢？

接口被引入Java是因为的钻石问题具有多重继承，这就是他们实际上打算做的。

接口是为解决多重继承问题而创建的构造，可以具有抽象方法、默认定义和静态最终变量。

见为什么Java允许静态的最终变量在接口时，他们只是为了契约？。

主要的一点是：

• 它提供了“对象”应该拥有的基本数据和/或它应该能够执行的功能。它关心对象的基本特征：它拥有什么和它能做什么。因此，从同一个抽象类继承的对象共享基本特征（泛化）。
• 界面面向功能。它定义了一个对象应该具有的功能。不管它是什么对象，只要它能完成这些在接口中定义的功能，就没问题。它忽略了其他一切。一个对象/类可以包含多个（组）功能；因此一个类有可能实现多个接口。

核心进展：

• 抽象类可以有属性、数据字段、方法（完整/不完整）。
• 如果方法或属性以抽象关键字定义，则必须在派生类中重写。（功能）
• 如果为抽象类中的方法或属性定义抽象关键字，则无法定义方法主体并为其获取/设置值必须在派生类中重写的属性。
• 抽象类不支持多重继承。
• 抽象类包含构造函数。
• 抽象类可以包含子类、函数、属性的访问修饰符。
• 只有抽象类的完全成员可以是静态的。
• 接口只能从另一个接口继承，不能从抽象类继承，抽象类可以从另一个抽象类或另一个接口继承。

优势：

• 它是一种契约，强制所有子类执行相同的层次结构或标准。
• 如果不同的实现是同类的，并且使用共同的行为或状态，那么抽象类更适合使用。
• 如果我们向抽象类添加一个新方法，那么我们可以选择提供默认实现，因此所有现有代码都可以正常工作。
• 它允许比接口更快的执行。（接口需要更多的时间在相应的类中找到实际的方法。）
• 它可以用于紧耦合和松耦合。

点击这里查看详情。http://pradeepatkari.wordpress.com/2014/11/20/interface-and-abstract-class-in-c-oops/

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

简单地说，我想说：

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

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

从Oracle留档

考虑使用抽象类如果：

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

考虑使用接口如果：

1. 你期望不相关的类会实现你的接口。例如，许多不相关的对象可以实现Serializable接口。
2. 您希望指定特定数据类型的行为，但不关心谁实现其行为。
3. 您想利用类型的多重继承。

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

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

Java8通过提供default方法特性，在一定程度上缩小了interface和abstract类之间的差距。

有关详细信息，请参阅此留档页面。

查看这个SE问题以获取代码示例以更好地理解。

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

这是对接口与抽象类的一个非常基本的理解。

总结它的最短方法是interface是：

1. 完全抽象，除了default和static方法；虽然它有default和static方法的定义（方法签名+实现），但它只有其他方法的声明（方法签名）。
2. 受制于比类更宽松的规则（一个类可以实现多个interface，并且interface可以从多个interface继承）。所有变量都是隐式常量，无论是否指定为public static final。所有成员都是隐式public，无论是否指定为4。
3. 通常用于保证实现类将具有指定的功能和/或与实现相同接口的任何其他类兼容。

同时，一个abstract类是：

1. 从完全抽象到完全实现，倾向于有一个或多个abstract方法。可以包含声明和定义，声明标记为abstract。
2. 一个成熟的类，受制于管理其他类的规则（只能从一个类继承），条件是它不能实例化（因为不能保证它已经完全实现）。可以有非常量成员变量。可以实现成员权限改造，限制成员为protected、private或私有包（未指定）。
3. 通常用于提供可以由多个子类共享的尽可能多的实现，或者提供程序员能够提供的尽可能多的实现。

或者，如果我们想把它归结为一句话：interface是实现类已经，但abstract类是子类是。

接口一般是没有逻辑只有签名的类。抽象类是有逻辑的类。两者都支持契约作为接口，所有方法都应该在子类中实现，但抽象地只应该实现抽象方法。什么时候使用接口，什么时候抽象？为什么使用接口？

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
}

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

许多初级开发人员犯了一个错误，他们认为接口、抽象类和具体类是同一事物的微小变化，并纯粹出于技术原因选择其中一个：

接口和抽象类虽然从技术角度看是相似的，但却具有完全不同的含义和目的。

总结

1. 接口定义了一个契约，一些实现将为您实现。

2. 抽象类提供了实现可以重用的默认行为。