search

博客列表 >静态延迟绑定及静态单例模式加载以及单例模式连接数据库操作以及类成员的重载，重载后的私有化操作

静态延迟绑定及静态单例模式加载以及单例模式连接数据库操作以及类成员的重载，重载后的私有化操作

卢先生
卢先生原创
2022年02月21日 11:53:51540浏览

静态延迟绑定
在未使用静态延迟绑定的时候，如果父类使用self时，子类继承了父类，在子类中重新赋值的时候，是继承父类的，也可以说是不生效的，但是在父类将self更改为static时，将改为延时绑定模式，开启延时绑定模式时，子类在重新赋值时，子类已延时绑定，最终的结果将是子类的结果。
### 单例模式
单例模式感觉是在数据库链接的时候经常用到，意思就是先设置一个静态属性，这个静态属性使用这个静态方法，静态方法内判断静态属性是否进行了实例化，如果没有进行实例化，就进行实例化一次，在子类中使用时，防止父类中已经调用（实例化了一次了），并不会在子类中重新调用时，需要将静态属性在子类中重新赋值，或者重新调用一遍，让他为空即可。

  1. <?php
  3. /**
  4.  * 
  5.  * 后期静态绑定 延迟静态绑定 static
  6.  * 
  7.  */
  8. /**
  9.  * 在创建类层次结构时，self关键字在编译时就已经确定了他的作用域范围，而不是在运行时（后期），
  10.  * self不能动态的与调用类进行绑定，我们后期（延迟）静态绑定
  11.  * 
  12.  * $this能动态的与调用类进行绑定。
  13.  * 
  14.  */
  16. class Employee
  17. {
  19.     public static $favSport = 'football';
  20.     public  static function watchTV()
  21.     {
  22.         echo 'watching ' . static::$favSport . '<br>';
  23.     }
  24. }
  26. class Execute extends Employee
  27. {
  29.     public static $favSport = 'polo';
  30. }
  32. echo Execute::watchTV();
  33. echo Execute::$favSport;
  34. // 延迟绑定时将 输出的部分，也就是最终的部分 self替换static
  36. class tbody
  37. {
  40.     public $favSsport = 'football';
  41.     public function ccTV()
  42.     {
  44.         echo 'cctv' . $this->favSsport . '节目';
  45.     }
  46. }
  48. class td extends tbody
  49. {
  51.     public $favSsport = '2';
  52. }
  53. $a = new td;
  54. $a->ccTV();
  56. // 非静态类既不需要进行延迟绑定，他是调用最终的部分
  58. //单例模式 只允许类被实例化一次
  60. class Father
  61. {
  62.     // 将构造器设置成私有的
  63.     private function __construct()
  64.     {
  65.     }
  66.     private function __clone()
  67.     {
  68.     }
  69.     // 设置一个受保护的属性 存储father类的实例
  70.     protected static $_instance;
  71.     // 获取father类的实例  唯一实例
  72.     //     static function getInstance()
  73.     //     {
  74.     //         if (self::$_instance === null)
  75.     //             //    将值赋值给静态属性
  76.     //             self::$_instance = new self;
  77.     //         // 返回的是一个对象
  78.     //         return self::$_instance;
  79.     //     }
  80.     // }
  81.     /////////////下面更改为延迟绑定//////////////
  82.     static function getInstance()
  83.     {
  84.         if (static::$_instance === null)
  85.             //    将值赋值给静态属性
  86.             static::$_instance = new static;
  87.         // 返回的是一个对象
  88.         return static::$_instance;
  89.     }
  90. }
  95. class son extends Father
  96. {
  97.     protected static $_instance;
  98. }
  99. var_dump(Father::getInstance());
  100. var_dump(son::getInstance());
  102. // 自己的见解，单例模式只允许实例化一次，其实就是在var_dump第一次执行的时候，已经执行了一次静态延迟绑定，所以在第二次调用子类的时候，
  103. // 实际上父类就已经调用一次了，所以在if判断分支的时候，并不会进入static::$_instance === null，而是跳过，直接输出结果，如果想他
  104. // 继续执行一次，需要在子类中，重新给static::$_instance === null赋值为空，也就是重新定义一次

单例模式链接数据库（非延迟静态）
单例链接（数据库操作链接演示，操作其他也类似）其实是将数据库的增删改查链接数据库封装到接口中，封装到接口中后，后面的由抽象类来完成一部分的工作，工作类也就是普通类继承一部分抽象类来完成所有的工作，接口提供一个方法，抽象类完成一个最主要的部分，工作类来完成所有的工作，下面的工作类都的 where判断感觉也可以直接写到类的里面，还没有测试，等测试下，完成了所有的类方法后封装成类属性或者方法，直接可以在最后进行调用

代码部分：

  1. <?php
  3. /***
  4.  * 单例模式链接数据库 应用程序跟设计库交互
  5.  * 
  6.  */
  8. namespace app\laolu;
  10. use PDO;
  12. interface idbBase
  13. {
  14.     ///增删改查
  15.     //插入
  16.     static function insert($db, $data);
  17.     //查询
  18.     static function select($db, $where = []);
  19.     // 更新
  20.     static function update($db, $where = []);
  21.     //删除
  22.     static function delete($db, $data, $where = []);
  24.     //数据库链接
  25.     static function doconnect($dsn, $user, $password);
  26. }
  28. abstract class adb implements idbBase
  29. {
  30.     private static $_instance;
  31.     private function __construct()
  32.     {
  33.     }
  34.     private function __clone()
  35.     {
  36.     }
  37.     static function doconnect($dsn, $user, $password)
  38.     {
  39.         //创建adb类的唯一实例  获取唯一的pdo对象
  40.         if (is_null(self::$_instance)) {
  41.             self::$_instance = new PDO($dsn, $user, $password);
  42.         }
  43.         return self::$_instance;
  44.     }
  45. }
  47. //工作类
  48. class Db extends adb
  49. {
  50.     ///增删改查
  51.     //插入
  52.     static function insert($db, $data)
  53.     {
  54.     }
  55.     //查询
  57.     // static function select($db, $where = [])
  58.     // {
  60.     //     $dbo = $db->query("SELECT * FROM `mj_user` LIMIT 3")->fetchAll(PDO::FETCH_ASSOC);
  61.     //     return $dbo;
  62.     // }
  63.     static function select($db, $where = ['uid' => 1])
  64.     {
  65.         foreach ($where as $key => $value) {
  66.             $sql = $key . '>' . $value;
  67.             // 组装循环条件   这里装成字符后再query语句里面填入where循环条件
  68.         }
  70.         $dbo = $db->query("SELECT * FROM `mj_user` WHERE " . $sql . " LIMIT 3")->fetchAll(PDO::FETCH_ASSOC);
  71.         return $dbo;
  72.     }
  74.     // 更新
  75.     static function update($db, $where = [])
  76.     {
  77.     }
  78.     //删除
  79.     static function delete($db, $data, $where = [])
  80.     {
  81.     }
  82. }
  85. $config = [
  86.     'type' => $type ?? 'mysql',
  87.     'host' => $host ?? 'localhost',
  88.     'dbname' => $dbname ?? 'ad',
  89.     'username' => $username ?? 'root',
  90.     'password' => $password ?? 'H9MvYSqY3JmAC4aj',
  91.     'port' => $port ?? '3306',
  92.     'charset' => $charset ?? 'utf8'
  93. ];
  94. extract($config);
  95. $dsn = sprintf('%s:host=%s;port=%s;charset=%s;dbname=%s', $type, $host, $port, $charset, $dbname);
  96. $pdo = Db::doconnect($dsn, $username, $password);
  97. $db1 = Db::select($pdo);
  98. var_dump($db1);
  99. var_dump(Db::select($pdo));
  100. // foreach ($db1 as $key => $value) {
  101. //     echo $key
  102. // }

重载就是php类中无该类属性成员（或私有属性）时，将自动创建类属性成员，也就是通过_set方法来创建的类属性成员，当访问这个属性是，使用的魔术方法__get 方法来访问这个类成员，类属性重载是将新类属性成员通过set get魔术方法来新建类属性，但魔术方法都是公开的，所以新建的类属性成员，私有属性成员都成为公开成员，违反了也忘了叫啥了。

  1. <?php
  3. /**
  4.  * php重载  overload
  5.  * php重载 方法拦截器 是指动态的创建类属性和方法，我们是通过魔术方法 来实现的， _get _set _callstatic _call
  6.  * 
  7.  * 当访问类中不存在或者不可见成员时，会自动调用魔术方法__set __get
  8.  * 因为魔术方法都是公开的，所以一些私有成员的不可见性就不会生效
  9.  * 
  10.  */
  12. class Credit
  13. {
  14.     public $name;
  15.     private $idNum;
  16.     public function __construct($name, $idNum)
  17.     {
  18.         $this->name = $name;
  19.         $this->idNum = $idNum;
  20.         var_dump($this->idNum);
  21.         echo "<br>上面输出了<br>";
  22.     }
  24.     public function __set($name, $value)
  25.     {
  26.         // echo '<hr>';
  27.         // echo $name . '<br>';
  28.         // echo $value . '<br>';
  29.         $this->$name = $value;
  30.         // var_dump($this->$name);
  31.         echo '<br>521314php<br>';
  32.         return $this->$name;
  33.     }
  34.     public function __get($name)
  35.     {
  36.         return $this->$name;
  37.     }
  38. }
  39. $a = new Credit('胡歌', '341621199905015488');
  40. echo $a->name;
  41. echo '<hr>';
  42. $ab = $a->name;
  43. echo $ab . '这里输出了<br>';
  44. $a->age = 20; //__set
  45. echo $a->age; //__get
  46. // echo $a->name;
  47. echo $a->idNum;//私有属性是通过__get魔术标签输出的

重载的私有属性或新类成员方法时解决方法：
在私有属性新赋值时，也是走的set 在进入set方法自动调用时，将set方法return出去的数据拦截，拦截组装出一个新的私有类成员方法，将在私有方法中输出结果，这样就将私有属性继续私有化，并不会公开化，当echo输出时，使用的__get魔术方法，但是传入的值，只是属性名，同样也是将属性私有化处理，新建一个私有方法，在get魔术方法中组装一个私有类成员方法
在下面使用中的新函数：

函数名 函数说明 使用方法
ucfirst() 将传入的值首字母大写 ucfirst($name)传入的name值将首字母大写处理
method_exists() 检查本作用域中是否有这个类成员方法 method_exists($this, $method) $this是本作用域，$method检查的变量
property_exists() 检查本类方法中是否存在这个类成员，属性类成员 property_exists($this, $name)前面是作用域，后面是检查的类成员 
  1. <?php
  3. class Credit
  4. {
  5.     private $name;
  6.     private $idNum;
  7.     public function __construct($name, $idNum)
  8.     {
  9.         $this->name = $name;
  10.         $this->idNum = $idNum;
  11.     }
  12.     //下面设置了一个私有的方法 这里的set相当于一个中转站
  13.     public function __set($name, $value) //name是拦截的属性的名,value是拦截的属性的值
  14.     {
  15.         // $this->$name = $value;
  16.         // return $this->$name; //这里将返回的属性值取消，暂时先不return出去
  17.         // 拼接实际调用的方法名称   ucfirst是将函数的第一个字母大写
  18.         $method = 'set' . ucfirst($name);
  20.         //下面判断 this本作用域中， 有没有$method这个类成员方法，也就是setidnum和setAge这个方法
  21.         if (method_exists($this, $method)) {
  22.             //这里相当于访问的是本作用域中的idnum方法，传入的值也是idnum的值
  23.             return  $this->$method($name, $value); //传入name是拦截的属性的名,value是拦截的属性的值  这里return出去 其中这里类属性已经变为了set*,比如下面的setIdNum
  24.         } else {
  25.             return  null;
  26.         }
  27.     }
  28.     private  function setAge($name, $value) //setIdNum这里相当于是未来私有方法的名称  $name是拦截的属性的名,value是拦截的属性的值
  29.     {
  30.         //设置信息
  31.         $ad = '改变为私有属性';
  32.         echo $ad;
  33.     }
  38.     private  function setIdNum($name, $value) //setIdNum这里相当于是未来私有方法的名称 
  39.     {
  40.         //设置信息 身份证号 做一些验证
  41.         // property_exists检查类中是否存在该属性 类属性 不是方法，$idNum 私有属性，是有的
  42.         if (property_exists($this, $name)) {
  43.             // strlen检查值是不是18位
  44.             return $this->$name = strlen($value) == 18 ? $value : null;
  45.         }
  46.     }
  48.     private function getIdNum($name)
  49.     {
  50.         // 只返回后6位
  51.         var_dump($name); //这里传入的是idNum也就是属性,其中下面this代表的是本类,也就是作用域.
  52.         $flag = property_exists($this, $name) && !empty($this->$name); //empty判断是否为空 
  53.         var_dump($flag);
  54.         if ($flag) {
  55.             return '*********' . mb_substr($this->$name, -6, 6);
  56.         } else {
  57.             return '操作违规信息不合法';
  58.         }
  59.     }
  61.     public function __get($name) //getIdNum  最终的值还是来到了魔术方法__get方法中
  62.     {
  63.         // return $this->$name;
  64.         $method = 'get' . ucfirst($name);
  66.         //下面判断 this本作用域中， 有没有$method这个类成员方法，也就是getIdNum这个方法
  67.         if (method_exists($this, $method)) {
  68.             //这里相当于访问的是本作用域中的idnum方法，传入的值也是idnum的值
  69.             return  $this->$method($name); //传入name是拦截的属性的名,value是拦截的属性的值   这里return出去的是getIdNum
  70.         } else {
  71.             return  null;
  72.         }
  73.     }
  74. }
  75. $a = new Credit('胡歌', '341621199905015488');
  76. // echo $a->name
  77. $a->age = 20; //__set
  78. // echo $a->age; //__get
  79. $a->idNum = '341621199905015488';
  80. echo $a->idNum;//私有属性是通过__get魔术标签输出的
上一条：云服务器为什么要设置防火墙？怎么设置防火墙？下一条：DOM 节点的克隆和导入
声明：本文内容转载自脚本之家，由网友自发贡献，版权归原作者所有，如您发现涉嫌抄袭侵权，请联系admin@php.cn 核实处理。
全部评论
文明上网理性发言，请遵守新闻评论服务协议

相关文章

查看更多