如何区别Trait、接口和抽象类

admin

一句话总结：

1、Trait是特征，类似函数，为了解决单继承不能多复用的问题，有实现、能复用、能多use。

1. a、使用Trait的类可以在类的内部使用use关键字，静态属性和方法在类的内部用self::，非静态的在类的内部使用$this->，类的外部需要先new类，然后使用$对象->属性或方法。
   
2. b、把多个类中重复的属性、方法抽出来写在一个Trait里。
   
3. c、在类的内部可以use多个Trait。
   
4. d、不参与继承，只是把代码“复制”进需要使用Trait的类里。
   
5. e、最适合通用功能、工具方法。

复制代码

例如：

1. trait A { }
   
2. trait B { }
   
3. class User {
   
4.     use A, B; // 多个
   
5. }

复制代码

在需要使用Trait的类里可以use多个Trait，中间用英文“,”隔开，例如：use A, B;
2、interface是接口，制定规则，只定方法名，不写方法体，只有规定没有实现。

1. a、只定义方法，不写具体的方法体。
   
2. b、在使用接口的类里必须实现接口中定义的所有方法。
   
3. c、一个类可以实现多个接口。
   
4. d、最适合强制规范，统一标准。

复制代码

关于一个类可以实现多个接口的说明：
即一个类可以implements多个接口，比如：

1. class User implements 接口1, 接口2, 接口3 {
   
2.     // 必须实现所有接口里的所有方法
   
3. }

复制代码

再比如：

1. // 接口1：必须能吃饭
   
2. interface Eat {
   
3.     public function eat();
   
4. }
   
5. 
   
6. // 接口2：必须能睡觉
   
7. interface Sleep {
   
8.     public function sleep();
   
9. }
   
10. 
    
11. // 接口3：必须能工作
    
12. interface Work {
    
13.     public function work();
    
14. }

复制代码

然后在类里实现：

1. // 这个类要同时遵守 3 套规矩
   
2. class User implements Eat, Sleep, Work
   
3. {
   
4.     // 实现 Eat 接口的方法
   
5.     public function eat()
   
6.     {
   
7.         echo "吃饭\n";
   
8.     }
   
9. 
   
10.     // 实现 Sleep 接口的方法
    
11.     public function sleep()
    
12.     {
    
13.         echo "睡觉\n";
    
14.     }
    
15. 
    
16.     // 实现 Work 接口的方法
    
17.     public function work()
    
18.     {
    
19.         echo "工作\n";
    
20.     }
    
21. }

复制代码

实例化并使用：

1. $user = new User();
   
2. $user->eat();
   
3. $user->sleep();
   
4. $user->work();

复制代码

3、abstract class是抽象类，半实现半规定，能写普通方法、抽象方法、属性，能继承，单继承。

1. a、在接口里可以写普通方法、抽象方法和属性。
   
2. b、单继承，一个类里只能extends一个抽象类。
   
3. c、不能实例化，只能被继承。
   
4. d、最适合父类（抽象类）定义通用逻辑，子类扩展。

复制代码

在类用使用extends继承抽象类，例如：

1. abstract class BaseUser {
   
2.     public function common() { }
   
3.     abstract public function func();
   
4. }
   
5. class User extends BaseUser {
   
6.     public function func() { }
   
7. }

复制代码

口诀和记忆：

1. 怎么选择？（实战口诀）
   
2. 1. 你需要复用代码 → 用 Trait
   
3. 多个类有一样的方法，抽出来复用。
   
4. 2. 你需要制定规范 / 强制实现方法 → 用 Interface
   
5. 比如：必须实现 login ()、logout ()。
   
6. 3. 你需要继承 + 共用属性 / 方法 → 用 抽象类
   
7. 父类定义通用逻辑，子类差异化实现。

复制代码

1. 最简单记忆法（必背）
   
2. Trait：我是搬运工，给你代码复用。
   
3. Interface：我是监工，只定规矩不干活。
   
4. Abstract：我是包工头，干一半，剩下让子类干。

复制代码

最终总结：

1. 最终总结（极简版）
   
2. Trait：代码复用，多 use，有实现，无常量。
   
3. 接口：制定规范，多实现，无实现、无属性。
   
4. 抽象类：模板类，单继承，有属性、有实现。

复制代码