接口定义了实现类必须实现的一组方法。

当trait被使用时，方法的实现也会出现——这在接口中不会发生。

这是最大的不同。

PHP RFC的水平重用:

trait是一种在单继承语言(如PHP)中代码重用的机制。Trait旨在通过允许开发人员在不同类层次结构中的几个独立类中自由地重用方法集来减少单个继承的一些限制。

主要的区别在于，对于接口，您必须在实现上述接口的每个类中定义每个方法的实际实现，因此您可以让许多类实现相同的接口但具有不同的行为，而trait只是注入到类中的代码块;另一个重要的区别是trait方法只能是类方法或静态方法，不像接口方法也可以(通常是)是实例方法。

trait本质上是PHP对mixin的实现，实际上是一组扩展方法，可以通过添加trait将其添加到任何类中。然后，这些方法成为该类实现的一部分，但不使用继承。

来自PHP手册(强调我的):

trait是单继承语言(如PHP. ...)中代码重用的一种机制它是对传统继承的补充，并支持行为的水平组合;也就是说，类成员的应用不需要继承。

一个例子:

trait myTrait {
    function foo() { return "Foo!"; }
    function bar() { return "Bar!"; }
}

有了上面的特征，我现在可以做以下事情:

class MyClass extends SomeBaseClass {
    use myTrait; // Inclusion of the trait myTrait
}

在这一点上，当我创建一个MyClass类的实例时，它有两个方法，称为foo()和bar()——它们来自myTrait。注意，trait定义的方法已经有一个方法体，而接口定义的方法没有。

此外，PHP与许多其他语言一样，使用单一继承模型——这意味着一个类可以从多个接口派生，但不能从多个类派生。但是，PHP类可以包含多个trait——这允许程序员包含可重用的部分——就像包含多个基类一样。

有几件事需要注意:

                      -----------------------------------------------
                      |   Interface   |  Base Class   |    Trait    |
                      ===============================================
> 1 per class         |      Yes      |       No      |     Yes     |
---------------------------------------------------------------------
Define Method Body    |      No       |       Yes     |     Yes     |
---------------------------------------------------------------------
Polymorphism          |      Yes      |       Yes     |     No      |
---------------------------------------------------------------------

多态:

在前面的例子中，MyClass扩展了SomeBaseClass, MyClass是SomeBaseClass的一个实例。换句话说，像SomeBaseClass[] bases这样的数组可以包含MyClass的实例。类似地，如果MyClass扩展了IBaseInterface，则IBaseInterface[]基数组可以包含MyClass的实例。trait不存在这样的多态结构——因为trait本质上只是为了程序员方便而复制到每个使用它的类中的代码。

优先级:

如手册所述:

从基类继承的成员被Trait插入的成员覆盖。优先级顺序是当前类的成员重写Trait方法，Trait方法反过来重写继承的方法。

所以，考虑下面的场景:

class BaseClass {
    function SomeMethod() { /* Do stuff here */ }
}

interface IBase {
    function SomeMethod();
}

trait myTrait {
    function SomeMethod() { /* Do different stuff here */ }
}

class MyClass extends BaseClass implements IBase {
    use myTrait;

    function SomeMethod() { /* Do a third thing */ }
}

当创建MyClass的实例时，会发生以下情况:

Interface IBase需要提供一个名为SomeMethod()的无参数函数。 基类BaseClass提供了该方法的实现—满足需求。 trait myTrait也提供了一个名为SomeMethod()的无参数函数，它优先于baseclass版本 类MyClass提供了它自己的SomeMethod()版本-它优先于特征版本。

结论

Interface不能提供方法体的默认实现，而trait可以。 接口是一种多态的、可继承的结构，而特征则不是。 在同一个职业中可以使用多个接口，也可以使用多个特征。

公共服务公告:

我想要声明的是，我相信trait几乎总是一种代码气味，应该避免使用组合。在我看来，单继承经常被滥用到反模式的地步，而多重继承只会加剧这个问题。在大多数情况下，使用组合而不是继承(无论是单个还是多个)会更好。如果您仍然对特征及其与界面的关系感兴趣，请继续阅读…

---

让我们这样开始:

面向对象编程(OOP)可能是一个难以掌握的范例。 仅仅因为你在使用类并不意味着你的代码就是 面向对象(OO)。

要编写OO代码，你需要理解OOP实际上是关于对象的功能。你必须考虑类可以做什么，而不是它们实际做什么。这与传统的过程式编程形成了鲜明的对比，在传统的过程式编程中，重点是让一小段代码“做一些事情”。

如果面向对象编程是关于规划和设计的，那么接口就是蓝图，对象就是完全建成的房子。与此同时，特征只是一种帮助建造蓝图(界面)所布置的房子的方法。

接口

那么，我们为什么要使用接口呢?很简单，接口使我们的代码不那么脆弱。如果您怀疑这种说法，可以问问那些被迫维护遗留代码的人，这些代码不是针对接口编写的。

接口是程序员和他/她的代码之间的契约。这个界面说:“只要你遵守我的规则，你可以随心所欲地实现我，我保证不会破坏你的其他代码。”

举个例子，考虑一个现实世界的场景(没有汽车或小部件):

你想为一个web应用程序实现一个缓存系统 服务器负载下降

你开始写一个类来缓存请求响应使用APC:

class ApcCacher
{
  public function fetch($key) {
    return apc_fetch($key);
  }
  public function store($key, $data) {
    return apc_store($key, $data);
  }
  public function delete($key) {
    return apc_delete($key);
  }
}

然后，在HTTP响应对象中，在执行生成实际响应的所有工作之前检查缓存命中:

class Controller
{
  protected $req;
  protected $resp;
  protected $cacher;

  public function __construct(Request $req, Response $resp, ApcCacher $cacher=NULL) {
    $this->req    = $req;
    $this->resp   = $resp;
    $this->cacher = $cacher;

    $this->buildResponse();
  }

  public function buildResponse() {
    if (NULL !== $this->cacher && $response = $this->cacher->fetch($this->req->uri()) {
      $this->resp = $response;
    } else {
      // Build the response manually
    }
  }

  public function getResponse() {
    return $this->resp;
  }
}

这种方法非常有效。但也许几周后你决定使用基于文件的缓存系统而不是APC。现在你必须改变你的控制器代码，因为你已经把你的控制器编程为使用ApcCacher类的功能，而不是一个表达ApcCacher类功能的接口。让我们假设你让Controller类依赖于CacherInterface而不是具体的ApcCacher，就像这样:

// Your controller's constructor using the interface as a dependency
public function __construct(Request $req, Response $resp, CacherInterface $cacher=NULL)

你可以这样定义你的界面:

interface CacherInterface
{
  public function fetch($key);
  public function store($key, $data);
  public function delete($key);
}

反过来，你让你的ApcCacher和你的新FileCacher类实现CacherInterface，你编程你的Controller类来使用接口所需的功能。

这个示例(希望)演示了如何通过接口编程来更改类的内部实现，而不用担心这些更改是否会破坏其他代码。

特征

另一方面，trait只是一种重用代码的方法。界面不应该被认为是与特征相排斥的选择。事实上，创建满足接口所需功能的特征是最理想的用例。

只有当多个类共享相同的功能(可能由相同的接口决定)时，才应该使用trait。使用trait为单个类提供功能是没有意义的:这只会混淆类的功能，更好的设计应该将trait的功能移到相关的类中。

考虑下面的trait实现:

interface Person
{
    public function greet();
    public function eat($food);
}

trait EatingTrait
{
    public function eat($food)
    {
        $this->putInMouth($food);
    }

    private function putInMouth($food)
    {
        // Digest delicious food
    }
}

class NicePerson implements Person
{
    use EatingTrait;

    public function greet()
    {
        echo 'Good day, good sir!';
    }
}

class MeanPerson implements Person
{
    use EatingTrait;

    public function greet()
    {
        echo 'Your mother was a hamster!';
    }
}

一个更具体的例子:假设接口讨论中的FileCacher和ApcCacher都使用相同的方法来确定缓存项是否过时，是否应该删除(显然在现实生活中不是这样的，但还是这样吧)。您可以编写一个trait，并允许两个类使用它来满足公共接口需求。

最后提醒一句:注意不要在性格特征上走极端。当独特的类实现就足够了的时候，特征常常被用作糟糕设计的拐杖。为了获得最佳的代码设计，你应该限制特征以满足界面需求。

如果你懂英语，知道trait的意思，它就是这个名字的意思。它是一个无类的方法和属性包，您可以通过输入use将其附加到现有类。

基本上，你可以将它与单个变量进行比较。闭包函数可以从作用域外部使用这些变量，这样它们就有了作用域内部的值。他们是强大的，可以在任何地方使用。如果trait被使用，也会发生同样的情况。

我认为trait对于创建包含方法的类是有用的，这些方法可以被用作几个不同类的方法。

例如:

trait ToolKit
{
    public $errors = array();

    public function error($msg)
    {
        $this->errors[] = $msg;
        return false;
    }
}

您可以在任何使用此特性的类中拥有并使用此“error”方法。

class Something
{
    use Toolkit;

    public function do_something($zipcode)
    {
        if (preg_match('/^[0-9]{5}$/', $zipcode) !== 1)
            return $this->error('Invalid zipcode.');
        
        // do something here
    }
}

而对于接口，你只能声明方法签名，而不能声明它的函数代码。此外，要使用接口，您需要遵循层次结构，使用实现。但特质却不是这样。

这是完全不同的!