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

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

}

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

在一个接口中，所有方法都只能是定义，而不能实现单个方法。

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

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

简单地说，我想说：

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

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

来自Oracle文档

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

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

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

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

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

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

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

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

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

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

要点：

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

优势：

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

在此处查找详细信息。。。http://pradeepatkari.wordpress.com/2014/11/20/interface-and-abstract-class-in-c-oops/

接口与抽象类的比较是错误的。应该有另外两个比较：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++，可能只有一个类，既不是抽象类也不是最终类。这样的类可以继承并实例化。不过，我认为这并不严格符合面向对象的范例。

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

一些重要的区别：

以表格的形式：

正如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接口速度较慢，因为它需要额外的间接寻址。