trait只是为了代码重用。

Interface只是提供了要在类中定义的函数的签名，它可以根据程序员的判断使用。这样就为我们提供了一组类的原型。

供参考, http://www.php.net/manual/en/language.oop5.traits.php

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，也可以在同一个类中使用'use keyword'来使用多个trait。

接口用于代码可重用性与特性相同

接口是扩展多个接口，所以我们可以解决多个继承问题，但当我们实现接口时，我们应该在类中创建所有的方法。 欲了解更多信息，请点击以下链接:

http://php.net/manual/en/language.oop5.traits.php http://php.net/manual/en/language.oop5.interfaces.php

公共服务公告:

我想要声明的是，我相信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视为代码的自动“复制-粘贴”。

使用trait是很危险的，因为在执行前我们无法知道它的作用。

然而，由于缺乏遗传等限制，性状更加灵活。

trait在注入方法时很有用，它可以检查类中是否存在另一个方法或属性。这是一篇不错的文章(但是是法语，抱歉)。

对于能读法语的人来说，GNU/Linux杂志HS 54有一篇关于这个主题的文章。

描述trait的一个常用比喻是:trait是带有实现的接口。

在大多数情况下，这是一种很好的思考方式，但两者之间存在一些微妙的差异。

首先，instanceof操作符不能与trait一起工作(即，trait不是一个真正的对象)，因此不能使用它来查看一个类是否具有某个trait(或者查看两个本来不相关的类是否共享一个trait)。这就是他们所说的横向代码重用的结构。

现在PHP中有一些函数可以让您获得类使用的所有特征的列表，但是特征继承意味着您需要进行递归检查，以可靠地检查类在某个时刻是否具有特定的特征(PHP doco页面上有示例代码)。不过，它当然不像instanceof那样简单干净，以我之见，这个特性会让PHP变得更好。

而且，抽象类仍然是类，因此它们不能解决与多重继承相关的代码重用问题。请记住，您只能扩展一个类(真实的或抽象的)，但可以实现多个接口。

我发现trait和接口非常适合一起使用来创建伪多重继承。例如:

class SlidingDoor extends Door implements IKeyed  
{  
    use KeyedTrait;  
    [...] // Generally not a lot else goes here since it's all in the trait  
}

这样做意味着您可以使用instanceof来确定特定的Door对象是否是Keyed的，您知道您将得到一组一致的方法，等等，并且所有的代码在所有使用KeyedTrait的类中都位于一个位置。