1. 类的静态成员、类引用self:: 2. 接口、抽象类、

编辑: admin 分类: 电脑知识 发布时间: 2023-06-14 来源:互联网
4.8.10 类的静态成员、类常量

静态成员、类常量是属于类本身，不需要实例化就可以被访问到，直接使用类名访问，减少实例化对象所占内存。

  1. static 标识静态成员（默认为 public，可以不写）

  2. const 类常量（不能用 define ），通常在类内部使用，不建议在类外部使用

  3. 在类内部，使用 self::访问静态成员（需要加$）、类常量（不需要加$），（不能使用 $this）

  4. __callStatic 当调用不存在或者没有权限访问的静态方法时，此魔术方法会被调用

  5. :: 范围解析符 self::用于类常量 静态成员的访问

  6. 类外部访问：className::静态成员（需要加$），className::类常量（不需要加$）
  1. class Teacher
  2. {
  3.   // 类常量
  4.   public const CATES = ['前端', '后端', '全栈'];
  6.   // 静态属性
  7.   public static $uname;
  8.   private static $salary;
  9.   // 不加访问控制，默认为 public
  10.   static $siteName = '海外运维网';
  11.   static $count = 0;
  13.   // 构造方法，创建对象时初始化属性
  14.   public function __construct($uname, $salary)
  15.   {
  16.     //静态成员与类的实例无关 不能使用$this来访问 使用self::访问静态成员  类常量
  17.     self::$salary = $salary;
  18.     self::$uname = $uname;
  19.     self::$count++;
  20.   }
  22.   static function getBK()
  23.   {
  24.     // 非静态成员是对象级别的存在，静态成员是类级别的存在，随着类的加载而加载，优先于对象存在的，在静态方法中无法访问非静态成员（此时还不存在对象）
  25.     return self::$uname . '来自' . self::$siteName . '可以胜任' . join(',', self::CATES) . '的相关课程';
  26.   }
  27. }
  29. $mj = new Teacher('灭绝师妹', 2000);
  30. echo Teacher::$uname;  // 灭绝师妹
  31. // 可以使用对象来访问，但不建议
  32. echo $mj::$uname;  // 灭绝师妹
  33. $mj1 = new Teacher('灭绝老师', 5000);
  34. // 实例化对象会改变静态属性的值，值为最后一次实例化的值，也会改变之前实例化的对象
  35. echo Teacher::$uname;  // 灭绝老师
  36. echo $mj::$uname;  // 灭绝老师
  37. //类常量不建议在类外访问
  38. print_r(Teacher::CATES);  // Array ( [0] => 前端 [1] => 后端 [2] => 全栈 )
  39. // 访问静态方法
  40. echo Teacher::getBK();  // 灭绝老师来自海外运维网可以胜任前端,后端,全栈的相关课程
  41. // 访问次数
  42. echo Teacher::$count;  // 2
4.8.11 接口、抽象类、trait4.8.11.1 接口、抽象类

  • 接口(interface)是定义，类(class)是实现。

    • 接口(interface)：定义方法（只有声明，没有实现），不能被实例化
    • 抽象类(abstract)：继承接口(interface)，重写并实现部分方法，不能被实例化，可以继承多个接口
    • 类(class)：继承抽象类，实现全部方法，可以实例化，只能继承一个父类（抽象类）
  1. // 接口(interface)
  2. interface iDemo
  3. {
  4.   // 所有成员必须是公开的(public)
  5.   public const gender = 'MALE';
  7.   // 接口(interface)所有方法都是抽象方法 只有声明 没有实现
  8.   public function sum($a, $b);
  9.   public function sub($a, $b);
  10.   public function mul($a, $b);
  11.   public function div($a, $b);
  12. }
  14. interface test
  15. {
  16.   public const T = 20;
  17. }
  19. // 抽象类(abstract)：
  20. // 抽象类 可以存在 抽象方法和工作方法 不能被实例化
  21. // 抽象类可以继承多个接口
  22. // 实现部分方法，剩余方法由类（class）完成
  23. abstract class aDemo implements iDemo, test
  24. {
  25.   // 重写接口 iDemo 中的 sum 方法
  26.   public function sum($a, $b)
  27.   {
  28.     return $a + $b;
  29.   }
  31.   // 重写接口 iDemo 中的 sub 方法
  32.   public function sub($a, $b)
  33.   {
  34.     return $a - $b;
  35.   }
  36. }
  38. // 类只能继承一个父类（抽象类）
  39. // 类(class)：实现全部方法，可以实例化
  40. class Work extends aDemo
  41. {
  42.   // 重写接口 iDemo 中的 mul 方法
  43.   public function mul($a, $b)
  44.   {
  45.     // 调用接口 test 中的常量 T
  46.     echo self::T;
  47.     return $a * $b;
  48.   }
  50.   // 重写接口 iDemo 中的 div 方法
  51.   public function div($a, $b)
  52.   {
  53.     return $a / $b;
  54.   }
  55. }
  57. $obj = new Work;
  58. $obj->mul(5,6);  // 20 ( echo self::T; )
  59. echo $obj->sum(10, 20); // 30
4.8.11.2 trait

  • trait是基于类的语法，但是和接口一样，不能被实例化 ，是对类功能的横向扩展。

  • php oop 默认是单继承 只能继承一个父类->高耦合

  • 一个类可以实现多个接口，多态
  • trait 功能组合式地实现多继承
  1. // 接上例的接口和抽象类
  2. // 定义 trait，扩展类的功能
  3. // 断点打印 t1
  4. trait t1
  5. {
  6.   public function dd($data)
  7.   {
  8.     var_dump($data);
  9.     die;
  10.   }
  11. }
  13. // 扩展 sum() 功能
  14. trait t2
  15. {
  16.   public function sum($a, $b, ...$args)
  17.   {
  18.     return $a + $b + array_sum($args);
  19.   }
  20. }
  22. class Work extends aDemo
  23. {
  24.   // 同名方法优先级 类同名方法（重写）>trait>继承成员方法
  25.   //trait 功能组合式地实现多继承
  26.   use t1, t2;
  28.   // 重写接口 iDemo 中的 mul 方法
  29.   public function mul($a, $b)
  30.   {
  31.     // 调用接口 test 中的常量 T
  32.     echo self::T;
  33.     return $a * $b;
  34.   }
  36.   // 重写接口 iDemo 中的 div 方法
  37.   public function div($a, $b)
  38.   {
  39.     return $a / $b;
  40.   }
  41.   // 类同名方法（重写），优先级最大
  42. //     public function sum($a, $b)
  43. //     {
  44. //         return 'hello';
  45. //     }
  46. }
  48. echo $obj->sum(10, 20, 30, 40, 200);  // 300 （trait t2）
  49. $obj->dd('你好');  // 你好（trait t1）
4.8.12 后期静态绑定

self:: 对当前类的静态引用是由限制的，self::取决于定义当前方法所在的类， 定义类与调用类（实例化的对象）不能动态绑定

  1. class Car
  2. {
  3.   // 私有静态方法 getName()
  4.   private static function getName(): string
  5.   {
  6.     return 'car';
  7.   }
  9.   public static function run()
  10.   {
  11.     // self:: 指向当前类，实例化的对象中依然指向当前类 Car
  12.     return self::getName();
  13.   }
  14. }
  16. class Benz extends Car
  17. {
  18.   // 重写父类的静态方法 getName()
  19.   public static function getName()
  20.   {
  21.     return 'E300';
  22.   }
  23. }
  25. echo Car::run();  // car
  26. // 调用类中 self::还是指向父类 Car，而不是指向调用类 Benz
  27. echo Benz::run();  // car

使用后期静态绑定 static::，不再被解析为定义当前方法所在的类，而是在调用类。

  1. class Car
  2. {
  3.   private static function getName(): string
  4.   {
  5.     return 'car';
  6.   }
  8.   public static function run()
  9.   {
  10.     // self:: 改为 static::
  11.     return static::getName();
  12.   }
  13. }
  15. class Benz extends Car
  16. {
  17.   public static function getName()
  18.   {
  19.     return 'E300';
  20.   }
  21. }
  23. echo Car::run();  // car
  24. // 后期静态绑定 static::，不再指向父类 Car，而是指向调用类 Benz
  25. echo Benz::run();  // E300
4.8.13 命名空间

  • 全局成员： 常量、命名函数、类（接口），不受作用域限制，重名的话会冲突

  • 命名空间：可以解决全局成员命名冲突的问题

    1. namespace ns1;
    3. class test
    4. {
    5.   public static function show()
    6.   {
    7.     //  __FUNCTION__ 只是返回方法(或者函数)的名字
    8.     // __METHOD__  返回类名和方法的名字（包括命名空间，如有）
    9.     return __METHOD__;
    10.   }
    11. }
    13. namespace ns2;
    15. class test
    16. {
    17.   public static function show()
    18.   {
    19.     return __METHOD__;
    20.   }
    21. }
    23. // 当前在命名空间 ns2，可以直接调用本空间下的类
    24. echo test::show();  // ns2\test::show
    25. // call_user_func() 回调，是异步，脱离了当前线程，不能直接调用，需要加上命名空间
    26. echo call_user_func(['test', 'show']); // 报错找不到test类
    27. echo call_user_func(['ns2\test', 'show']); // ns2\test::show
    29. // 从非全局命名空间（当前为 ns2）访问别的空间中的类 先回到root: \
    30. // 注意：这里的反斜杠（\）是空间分隔符，不是目录分隔符
    31. echo \ns1\test::show();  // ns1\test::show

  • 命名空间下的函数，优先级高于系统同名函数 （系统函数默认在全局命名空间）

    1. namespace demo;
    3. function var_dump($data)
    4. {
    5.   echo 'var_dump' . $data;
    6. }
    8. var_dump('你好');  // var_dump你好
4.8.14 use 在命名空间中的使用

目录结构：

  • tp6
    • app
      • controller
        • Index.php
        • Login.php
    • autoload.php
    • index.php

app\controller 下面的两个类（命名空间设置为类所在的目录）

  • Index.php

    1. namespace app\controller;
    3. class Index
    4. {
    5.   static function index()
    6.   {
    7.     return __METHOD__ . "<br />";
    8.   }
    9. }

  • Login.php

    1. namespace app\controller;
    3. class Login
    4. {
    5.   static function index()
    6.   {
    7.     return __METHOD__ . "<br />";
    8.   }
    9. }

autoload.php：类的自动加载器

  1. spl_autoload_register(function ($className) {
  2.   // 自动加载器引入的类名 $className 是带有命名空间的（app\controller\Index）
  3.   // 命名空间名称与目录树对应，可以参与类文件所在位置的拼接
  4.   // 命名空间的反斜杠（\）是空间分隔符，不是目录分隔符，需要转换为目录分割符
  5.   // "\\"：第一个 \ 是转义符，第二个 \ 是空间分隔符
  6.   $file = str_replace("\\", DIRECTORY_SEPARATOR, $className) . '.php';
  7.   if (is_file($file) && file_exists($file)) require $file;
  8. });

index.php：入口文件，使用 use 引入其他命名空间中的类

  1. // 入口文件
  2. // 注意：入口文件不能放在类所在的目录，否则无法引入
  3. require __DIR__ . DIRECTORY_SEPARATOR . 'autoload.php';
  4. // 1. 直接调用其他命名空间中的类，需加上命名空间
  5. // 无需 use app\controller;
  6. // 当前为全局命名空间，无需加 root：\
  7. echo app\controller\Index::index();  // app\controller\Index::index
  9. // 如果需要给命名空间起别名，则需要 use as
  10. use app\controller as ac;
  12. echo ac\login::index();  // app\controller\Login::index
  14. // 2. use 引入其他命名空间中的类，然后可以直接调用改类
  15. use app\controller\Index;
  16. use app\controller\Login;
  18. echo Index::index();  // app\controller\Index::index
  19. echo Login::index();  // app\controller\Login::index
  21. // 给引入的类起别名： use as
  22. // 不起别名，默认为Index
  23. use app\controller\Index as in;
  25. echo in::index();  // app\controller\Index::index
【文章转自韩国站群多ip服务器 http://www.558idc.com/krzq.html处的文章,转载请说明出处】
更多阅读