search

博客列表 >0815-类扩展（继承），抽象和接口、全局成语和命名空间

0815-类扩展（继承），抽象和接口、全局成语和命名空间

三九三伏
三九三伏原创
2022年08月30日 19:42:11483浏览

一、类扩展（继承），抽象，接口

属性重载

__get(), __set()

  1. <?php
  3. namespace _0815;
  5. /////////////demo1//////////////
  6. /**
  7.  * 属性重载 __get(),__set()
  8.  *
  9.  */
  11. //封装，重载，继承
  12. class User
  13. {
  14.     //private:私有封装
  15.     private array $data = [
  16.         'age' => 20,
  17.     ];
  19.     //查询接口
  20.     public function __get($name)
  21.     {
  22.         $condition = array_key_exists($name, $this->data) ;
  23.         return $condition ? $this->data[$name] : "$name 属性不存在"; 
  24.     }
  26.     //设置接口
  27.     public  function __set($name, $value)
  28.     {
  29.         $condition = array_key_exists($name, $this->data) ;
  31.         if(!$condition){
  32.             //这里如果不做提示和返回，对于把age错写成ag3，echo时又写对成age，是不是不好定位设置值不成功的问题？
  33.             echo "$name 属性不存在<br>";
  34.             // 但是这里出现了多处返回，是不是部分编辑器会报错？
  35.             return ;
  36.         }
  38.         return $condition ? $this->data[$name] : "$name 属性不存在"; 
  39.     }
  40. }
  42. $user =new User();
  43. echo $user->age.'<br>';
  44. $user->ag3 = 10;
  45. echo $user->age.'<br>';

遗留问题：
如上述代码注释所述，array_key_exist在__set中应用，多处return是否可以？不可以，如何处理注释中提到的问题？

方法重载

__call(), static function __callStatic()

  1. <?php
  3. namespace _0815;
  5. /////////////demo1//////////////
  6. /**
  7.  * 属性重载 __get(),__set()
  8.  * 方法重载 __call($name, $args), __callStatic($name, $args)
  9.  */
  11. //封装，重载，继承
  12. class User
  13. {
  14.     //private:私有封装
  15.     private array $data = [
  16.         'age' => 20,
  17.     ];
  19.     //查询接口
  20.     public function __get($name)
  21.     {
  22.         $condition = array_key_exists($name, $this->data) ;
  23.         return $condition ? $this->data[$name] : "$name 属性不存在"; 
  24.     }
  26.     //设置接口
  27.     public  function __set($name, $value)
  28.     {
  29.         $condition = array_key_exists($name, $this->data) ;
  31.         if(!$condition){
  32.             //这里如果不做提示和返回，对于把age错写成ag3，echo时又写对成age，是不是不好定位设置值不成功的问题？
  33.             echo "$name 属性不存在<br>";
  34.             // 但是这里出现了多处返回，是不是部分编辑器会报错？
  35.             return ;
  36.         }
  38.         return $condition ? $this->data[$name] : "$name 属性不存在"; 
  39.     }
  41.     // 可以自动拦截对方法的非法请求
  42.     public function __call($name, $arguments)
  43.     {
  44.         printf('非法动态方法：%s,<pre>%s</pre>.<br>', $name, print_r($arguments, true));
  45.     }
  46.     // 拦截对静态方法的非法请求
  47.     public static function __callStatic($name, $arguments)
  48.     {
  49.         printf('非法静态方法：%s,<pre>%s</pre>.<br>', $name, print_r($arguments, true));
  50.     }
  51. }
  53. $user =new User();
  54. echo $user->age.'<br>';
  55. $user->ag3 = 10;
  56. echo $user->age.'<br>';
  58. // 非静态方法
  59. $user->hello('路人甲','4352259');
  60. // 静态方法
  61. User::world('路人乙','28375985');

THINKPHP查询构造器模拟

  1. //ThinkPHP,查询构造器，数据库操作
  2. class Query
  3. {
  4.     public function table() 
  5.     {
  6.         echo 'Query table()->';
  7.         return $this;
  8.     }
  9.     public function where()
  10.     {
  11.         echo 'Query where()->';
  12.         return $this;
  13.     }
  14.     public function find()
  15.     {
  16.         echo 'Query find()<br>';
  17.     }
  18. }
  20. // 查询入口
  21. class Db
  22. {
  23.     //实例化时自动连接数据库
  24.     // public function __construct()
  25.     // {
  26.     //     self::connect();
  27.     // }
  28.     public static function __callStatic($name, $arguments)
  29.     {
  30.         // printf('方法：%s,参数：<pre>%s</pre>',$name, print_r($arguments, true));
  31.         // 所有查询在此完成，单入口查询
  32.         return call_user_func_array([new Query, $name] , $arguments);
  33.     }
  34. }
  36. Db::table('think_user')->where('id', 1)->find();

类扩展（继承）

  1. /**
  2.  * 类的扩展(继承)/抽象/最终
  3.  * 1. 可继承成员protected
  4.  * 2. extends: 类成员的来源
  5.  * 3. parent：父类引用
  6.  */
  8. class Person
  9. {
  10.     //属性
  11.     // public：公共成员，类内、子类、类外部可访问
  12.     public string $email = 'admin@php.cn';
  13.     // private：私有成员，类内可访问。
  14.     private int $id = 10;
  15.     //protected：受保护成员，类内、子类可访问。
  16.     protected string $name;
  18.     //方法
  19.     public function __construct($name)
  20.     {
  21.         $this->name =$name;
  22.     }
  24.     // 自定义方法
  25.     protected function getInfo():string
  26.     {
  27.         return $this->name;
  28.     }
  29. }
  31. class Stu extends Person
  32. {
  33.     //只需要扩展属性和方法
  34.     // 属性扩展
  35.     private string $lesson;
  36.     private int $score;
  38.     //方法扩展
  39.     // 构造方法扩展
  40.     public function __construct($name, $lesson, $score)
  41.     {
  42.         //引用父类
  43.         parent::__construct($name);
  45.         $this->lesson = $lesson;
  46.         $this->score =$score;
  47.     }
  49.     // 为方便外部访问，由public定义
  50.     public    function getInfo(): string
  51.     {
  52.         return parent::getInfo().'同学，'.$this->lesson.'成绩：'.$this->score.'<br>';
  53.     }
  54. }
  56. $stu = new Stu('路人甲', 'php', 99);
  57. echo $stu->getInfo();

抽象类

  1. // 禁用父类，仅允许通过他的子类来访问父类成员。
  2. // 把当前类声明为抽象类abstract。
  3. // 如果类中有抽象方法，则必须声明为抽象类。
  4. abstract class demo1
  5. {
  6.     public string $name = 'admin';
  8.     // 抽象方法，没有具体实现体的方法应该声明成抽象方法。
  9.     abstract public static function getInfo($name);
  11. }
  13. class demo2 extends demo1
  14. {
  15.     // 在子类中必须实现父类抽象方法，否则报错。
  16.     public static function getInfo($name) 
  17.     {
  18.         return 'Hello,'.$name;
  19.     }
  20. }
  22. echo demo2::getInfo('路人甲');

最终类

  1. // final最终类，禁止继承，直接用
  2. final class demofin
  3. {
  5. }
  6. //继承会报错
  7. class demo extends demofin
  8. {
  10. }

接口

  1. //接口：升级版的抽象类
  3. interface iUser
  4. {
  5.     //接口的属性必须是常量
  6.     public const NATION = 'CHINA';
  8.     //接口方法必须是public
  9.     public function m1();
  10.     public function m2();
  11. }
  13. // 工作类：实现接口内容
  14. class demo1 implements iUser
  15. {
  16.     // 接口中的抽象方法必须在工作类中全部实现
  17.     public function m1()
  18.     {
  19.     }
  20.     public function m2()
  21.     {
  22.     }
  23. }
  25. // 仅实现一部分，需声明为抽象子类
  26. abstract class Demo2 implements iUser
  27. {
  28.     public function m1()
  29.     {
  30.     }
  31. }
  33. class demo3 extends Demo2
  34. {
  35.     public function m2()
  36.     {
  38.     }
  39. }
  41. // php是单继承，可以通过接口间接多继承，不推荐
  42. interface A
  43. {
  44. }
  45. interface B 
  46. {
  47. }
  48. interface C
  49. {
  50. }
  51. // 多继承
  52. class Test implements A, B, C
  53. {
  54. }
  57. interface iDb
  58. {
  59.     // 插入
  60.     public static function insert(array $data);
  62.     // 更新
  63.     public static function update(array $data, string $where);
  65.     // 删除
  66.     public static function delete(string $where);
  68.     // 查询
  69.     public static function select(array $options);
  70. }
  72. //这个地方上课时没有implements，是默认的么？
  73. abstract class aDb implements iDb
  74. {
  75.     // 插入
  76.     public static function insert(array $data)
  77.     {
  78.     }
  80.     // 更新
  81.     public static function update(array $data, string $where)
  82.     {
  83.     }
  85.     // 删除
  86.     public static function delete(string $where)
  87.     {
  88.     }
  90.     // 查询
  91.     public static function select(array $options)
  92.     {
  93.     }
  94. }
  96. class Db extends aDb
  97. {
  99. }

二、全局成员和命名空间

全局成员

全局成员：函数，常量，类/接口,全局有效，禁止重复声明

命名空间

作用

解决全局成员命名冲突问题

声明

  1. namespace _0815;
  2. function hello()
  3. {
  5. }
  7. const A = 1;
  8. class D 
  9. {
  11. }
  16. namespace _0815_1;
  17. function hello()
  18. {
  20. }
  21. const A = 1;
  22. class D 
  23. {
  25. }

跨空间访问

  1. namespace one;
  3. class Demo1
  4. {
  5.     public static string $name = 'admin';
  6. }
  7. // 当存在命名空间时，全局成员应该使用完整名称。
  8. // 完整类名 = 空间名称\类名
  9. // ::class 获取完整类名
  10. echo Demo1::class.'<br>';
  11. namespace two;
  13. class demo1
  14. {
  15.     public static string $name = '路人甲';
  16. }
  17. echo Demo1::class.'<br>';
  19. // 跨空间访问
  20. // echo one\Demo1::$name;->实际访问’two\one\Demo1‘
  21. // 要从根空间'\'开始
  22. echo \one\Demo1::$name;

命名空间的类型

  1. // 1. 当前路径：非限定名称 Index
  2. // 2. 相对路径：限定名称 two\Index
  3. // 3. 绝对路径：完全限定名称 \one\two\Index
  5. namespace _0815;
  8. namespace one;
  10. class index
  11. {
  12.     public static function show()
  13.     {
  14.         return __METHOD__;
  15.     }
  16. }
  17. echo Index::show().'<br>';
  18. echo two\Index::show().'<br>';
  20. // 空间可分层
  21. namespace one\two;
  22. class index
  23. {
  24.     public static function show()
  25.     {
  26.         return __METHOD__;
  27.     }
  28. }
  29. echo Index::show().'<br>';

命名冲突

use起别名简化长度

  1. namespace one;
  3. class Index
  4. {
  5.     public static function show()
  6.     {
  7.         return __METHOD__;
  8.     }
  9. }
  11. echo \one\two\three\Index::show().'<br>';
  12. // use默认使用完全限定名称的类名/绝对路径,用别名简化长度。
  13. use \one\two\three\Index as UserIndex;
  14. echo UserIndex::show().'<br>';
  16. //-----------------------------------------
  17. namespace one\two\three;
  18. class Index
  19. {
  20.     public static function show()
  21.     {
  22.         return __METHOD__;
  23.     }
  24. }


上面代码中，如果namespace one没有Index类，那么use可以直接起别名Index，

  1. ...
  2.     use \one\two\three\Index as Index;
  3.     echo Index::show().'<br>';

当前类别名Index与原始类名相同，还可以不写

  1. ...
  2.     use \one\two\three\Index;
  3.     echo Index::show().'<br>';
上一条：0826 安装 配置thinkphp ，数据库操作：增删查改下一条：裁员大环境下，技术开发公司如何将成本降到最低？
声明：本文内容转载自脚本之家，由网友自发贡献，版权归原作者所有，如您发现涉嫌抄袭侵权，请联系admin@php.cn 核实处理。
全部评论
文明上网理性发言，请遵守新闻评论服务协议

相关文章

查看更多