1.简介

自 PHP 5.4.0 起，PHP 实现了一种代码复用的方法，称为 trait。

Trait 是为类似 PHP 的单继承语言而准备的一种代码复用机制。Trait 为了减少单继承语言的限制，使开发人员能够自由地在不同层次结构内独立的类中复用 method。Trait 和 Class 组合的语义定义了一种减少复杂性的方式，避免传统多继承和 Mixin 类相关典型问题。

Trait 和 Class 相似，但仅仅旨在用细粒度和一致的方式来组合功能。 无法通过 trait 自身来实例化。它为传统继承增加了水平特性的组合；也就是说，应用的几个 Class 之间不需要继承。

trait的类不能实例化；

1.2 优先级

从基类继承的成员会被 trait 插入的成员所覆盖。优先顺序是来自当前类的成员覆盖了 trait 的方法，而 trait 则覆盖了被继承的方法。

  1. //基类
  2. class Base{
  3.     public function sayHello(){
  4.         echo "base Hello";
  5.     }
  6. }
  7. // trait 类
  8. trait SayWorld{
  10.     public function sayHello(){
  11.         echo "trait Hello";
  12.     }
  13. }
  14. // 类
  15. class MyHello extends Base{
  16.     use SayWorld;
  17. }
  19. $obj = new MyHello();
  20. $obj->sayHello();

    // 结果：trait Hello

 

1.3 多个trait

通过逗号分隔，在 use 声明列出多个 trait，可以都插入到一个类中。

  1. //基类
  2. class Base{
  3.     public function sayHello(){
  4.         echo "base Hello";
  5.     }
  6. }
  7. // trait 类
  8. trait SayWorld{
  10.     public function sayHello(){
  11.         echo "trait Hello";
  12.     }
  13. }
  14. trait World{
  15.     public function sayWorld(){
  16.         echo 'trait World';
  17.     }
  18. }
  19. // 类
  20. class MyHello extends Base{
  21.     use SayWorld,World;
  22.     public function sayHello(){
  23.         echo "MyHello Hello";
  24.     }
  25. }
  27. $obj = new MyHello();
  28. $obj->sayHello();
  29. echo '<br/>';
  30. $obj->sayWorld();
    //结果：
    MyHello Hello
    trait World

 

1.4 trait 冲突的解决　

如果两个 trait 都插入了一个同名的方法，如果没有明确解决冲突将会产生一个致命错误。

为了解决多个 trait 在同一个类中的命名冲突，需要使用 insteadof 操作符来明确指定使用冲突方法中的哪一个。

以上方式仅允许排除掉其它方法，as 操作符可以 为某个方法引入别名。 注意，as 操作符不会对方法进行重命名，也不会影响其方法。

Example #5 冲突的解决

在本例中 Talker 使用了 trait A 和 B。由于 A 和 B 有冲突的方法，其定义了使用 trait B 中的 smallTalk 以及 trait A 中的 bigTalk。

Aliased_Talker 使用了 as 操作符来定义了 talk 来作为 B 的 bigTalk 的别名

  1. trait A{
  2.     public function small(){
  3.         echo 'a';
  4.     }
  5.     public function big(){
  6.         echo 'A';
  7.     }
  8.     public function mid(){
  9.         echo 'mid';
  10.     }
  11. }
  12. trait B{
  13.     public function small(){
  14.         echo 'b';
  15.     }
  16.     public function big(){
  17.         echo 'B';
  18.     }
  19. }
  21. class Talker{
  22.     use A,B {
  23.         B::small insteadof A;//small 方法使用B中的方法
  24.         A::big insteadof B;
  25.         A::mid insteadof B;
  26.         B::big as talk;
  27.     }
  28. }
  30. $obj = new Talker();
  31. $obj->talk();

 

1.5 修改方法的访问控制

  1. trait Hello{
  2.     public function sayHello(){
  3.         echo 'Hello';
  4.     }
  5. }
  7. class MyHello{
  8.     use Hello{
  9.         sayHello as protected;//修改访问权限
  10.         // sayHello as b  // 起个别名
  11.     }
  12. }
  14. class Myclass{
  15.     use Hello{
  16.         sayHello as private pHello; //修改访问权限的别名
  17.     }
  18. }
  19. $obj = new Myclass();
  21. $obj->sayHello();

 

1.6 从trait来组成trait

正如 class 能够使用 trait 一样，其它 trait 也能够使用 trait。在 trait 定义时通过使用一个或多个 trait，能够组合其它 trait 中的部分或全部成员

  1. trait Hello{
  2.     public function say(){
  3.         echo 'Hello';
  4.     }
  5. }
  7. trait World{
  8.     public function sayWorld(){
  9.         echo 'World';
  10.     }
  11. }
  13. trait HelloWorld{
  14.     use Hello,World;
  15. }
  17. class MyHelloWorld{
  18.     use HelloWorld;
  19. }
  21. $obj = new MyHelloWorld();
  23. $obj->sayWorld();

 

1.7 trait的抽象成员

为了对使用的类施加强制要求，trait 支持抽象方法的使用。

  1. trait Hello{
  2.     public function say(){
  3.         echo 'Hello';
  4.     }
  5.     abstract public function get();
  6. }
  10. class MyHelloWorld{
  11.     use Hello;
  12.     // trait中的抽象方法,必须实现
  13.     public function get(){
  14.         echo "Hello World";
  15.     }
  16. }
  18. $obj = new MyHelloWorld();
  20. $obj->say();

 

1.8 静态成员

  1. trait Counter{
  2.     public $num = 1;
  3.     public function inc(){
  4.         static $c = 0;
  5.         $c++;
  6.         echo $c;
  7.         $this->num = 2;
  8.     }
  9.     // 静态方法
  10.     public static function get(){
  11.         echo 'vic';
  12.     }
  13. }
  15. class C1{
  16.     use Counter;
  17. }
  18. $obj = new C1();
  20. $obj->inc(); //1
  21. $obj->inc();// 2
  22. C1::get();//vic
  23. Counter::get();//trait不可以实例化，但是静态方法可以调用
  24. $obj = new C1();
  26. $obj->inc();//3
  27.  
  28. class C2{
  29.     use Counter;
  30. }
  32. $obj = new C2();
  33. $obj->inc();//1
  34. echo $obj->num;//2

 

1.9 属性

Trait 定义了一个属性后，类就不能定义同样名称的属性，否则会产生 fatal error。 有种情况例外：属性是兼容的（同样的访问可见度、初始默认值）。

在 PHP 7.0 之前，属性是兼容的，则会有 E_STRICT 的提醒。

  1. trait PropertiesTrait {
  2.     public $same = true;
  3.     public $different = false;
  4. }
  6. class PropertiesExample {
  7.     use PropertiesTrait;
  8.     public $same = true; // PHP 7.0.0 后没问题，之前版本是 E_STRICT 提醒
  9.     public $different = true; // 致命错误
  10. }

 

1.10 trait 静态化

  1. trait Counter{
  2.     public $num = 1;
  3.     public function inc(){
  4.         static $c = 0;
  5.         $c++;
  6.         echo $c;
  7.         $this->num = 2;
  8.     }
  9.     // 静态方法
  10.     public static function get(){
  11.         return new static();//不是new的trait，是new的调用者
  12.     }
  13. }

 

参考资料：http://php.net/manual/zh/language.oop5.traits.php

　　　　    https://www.cnblogs.com/CraryPrimitiveMan/p/4162738.html

 

 

 

 

 

 

 

 

 

 

 

版权声明：本文为myvic原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：http://www.cnblogs.com/myvic/p/8057590.html