面向对象（六）Trait特性

我就是我 2022-02-25 15:48 240阅读 0赞

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

1、类中的一般的特性Trait都可以实现。但是要混入类中，而不是代替类

2、Trait是为了减少单继承语言的限制，例如需要同时继承两个抽象类，这是PHP语言不支持的功能，Trait就是为了解决这个问题

在继承类链中隔离了子类继承父类的某些特性，相当于要用父类特性的时候，如果有Trait在就优先调用Trait的成员

**一、Trait的声明**

1、使用Trait关键字。支持final，static和abstract等修饰词，所以trait也就支持抽象方法的使用、类定义静态方法，也可以定义属性。

2、但Trait无法如类一样new实例化，因为Trait就是用来混入类中使用的，不能单独使用。如果拿Interface和Trait类比，Trait会有更多方便的地方。

**二、优先级**

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

class Base {
        public function sayHello() {
            echo 'Hello ';
        }
    }
    
    trait SayWorld {
        public function sayHello() {
            parent::sayHello();
            echo 'World!';
        }
    }
    
    class MyHelloWorld extends Base {
        use SayWorld;
    }
    
    $o = new MyHelloWorld();
    $o->sayHello();//Hello World!

**三、多个Trait**

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

trait Hello {
        public function sayHello() {
            echo 'Hello ';
        }
    }
    
    trait World {
        public function sayWorld() {
            echo 'World';
        }
    }
    
    class MyHelloWorld {
        use Hello, World;
        public function sayExclamationMark() {
            echo '!';
        }
    }
    
    $o = new MyHelloWorld();
    $o->sayHello();//Hello
    $o->sayWorld();//World
    $o->sayExclamationMark();//!

2、冲突的解决

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

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

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

trait A {
        public function smallTalk() {
            echo 'a';
        }
        public function bigTalk() {
            echo 'A';
        }
    }
    
    trait B {
        public function smallTalk() {
            echo 'b';
        }
        public function bigTalk() {
            echo 'B';
        }
    }
    
    /*
    在本例中 Talker 使用了 trait A 和 B。由于 A 和 B 有冲突的方法，其定义了使用 trait B 中的 smallTalk 以及
    trait A 中的 bigTalk。
    */
    class Talker {
        use A, B {
            B::smallTalk insteadof A;
            A::bigTalk insteadof B;
        }
    }
    
    //Aliased_Talker 使用了 as 操作符来定义了 talk 来作为 B 的 bigTalk 的别名。
    class Aliased_Talker {
        use A, B {
            B::smallTalk insteadof A;
            A::bigTalk insteadof B;
            B::bigTalk as talk;
        }
    }
    
    $Talker = new Talker;
    echo $Talker->smallTalk();//b
    echo $Talker->bigTalk();//A
    
    $Aliased_Talker = new Aliased_Talker;
    echo $Aliased_Talker-> smallTalk();//b
    echo $Aliased_Talker-> bigTalk();//A
    echo $Aliased_Talker-> talk();//B

3、修改方法的访问控制

使用 *as* 语法还可以用来调整方法的访问控制。

trait HelloWorld {
        public function sayHello() {
            echo 'Hello World!';
        }
    }
    
    // 修改 sayHello 的访问控制
    class MyClass1 {
        use HelloWorld { sayHello as protected; }
    }
    
    // 给方法一个改变了访问控制的别名
    // 原版 sayHello 的访问控制则没有发生变化
    class MyClass2 {
        use HelloWorld { sayHello as private myPrivateHello; }
    }

**四、从 trait 来组成 trait**

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

trait Hello {
        public function sayHello() {
            echo 'Hello ';
        }
    }
    
    trait World {
        public function sayWorld() {
            echo 'World!';
        }
    }
    
    trait HelloWorld {
        use Hello, World;
    }
    
    class MyHelloWorld {
        use HelloWorld;
    }
    
    $o = new MyHelloWorld();
    $o->sayHello();//Hello
    $o->sayWorld();//World

**五、Trait 的抽象成员**

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

trait Hello {
        public function sayHelloWorld() {
            echo 'Hello '.$this->getWorld();
        }
        abstract public function getWorld();
    }
    
    class MyHelloWorld {
        private $world;
        use Hello;
        public function getWorld() {
            return $this->world;
        }
        public function setWorld($val) {
            $this->world = $val;
        }
    }
    
    $MyHelloWorld = new MyHelloWorld;
    $MyHelloWorld->setWorld('America');
    echo $MyHelloWorld->sayHelloWorld();//Hello America

**六、Trait 的静态成员**

Traits 可以被静态成员静态方法定义。

trait Counter {
        public function inc() {
            static $c = 0;
            $c = $c + 1;
            echo "$c\n";
        }
    }
    
    class C1 {
        use Counter;
    }
    
    class C2 {
        use Counter;
    }
    
    $o = new C1(); $o->inc();$o->inc(); // echo 1 2
    $p = new C2(); $p->inc(); // echo 1

trait StaticExample {
        public static function doSomething() {
            return 'Doing something';
        }
    }
    
    class Example {
        use StaticExample;
    }
    
    Example::doSomething();

**七、属性**

Trait 定义了一个属性后，类就不能定义同样名称的属性，否则会产生 fatal error。 有种情况例外：属性是兼容的（同样的访问可见度、初始默认值）。 但在 PHP 7.0 之前，即使属性是兼容的，也会有 E\_STRICT 的提醒。

trait PropertiesTrait {
        public $x = 1;
    }
    
    class PropertiesExample {
        use PropertiesTrait;
    }
    
    $example = new PropertiesExample;
    $example->x;

trait PropertiesTrait {
        public $same = true;
        public $different = false;
    }
    
    class PropertiesExample {
        use PropertiesTrait;
        public $same = true; // PHP 7.0.0 后没问题，之前版本是 E_STRICT 提醒
        public $different = true; // 致命错误
    }