search

博客列表 >1205课程，单例类，工厂模式，依赖注入，面向接口编程

1205课程，单例类，工厂模式，依赖注入，面向接口编程

张浩刚
张浩刚原创
2019年12月07日 23:22:57838浏览

单例类

  1. <?php
  2. namespace _1205;
  3. use PDO;
  4. class demo{
  6. }
  7. $obj1 = new demo();
  8. $obj2 = new demo();
  9. var_dump($obj1 == $obj2); //true
  10. echo '<hr>';
  11. var_dump($obj1 === $obj2); //false
  12. echo '<hr>';
  13. //单例模式
  14. //当构造方法被私有化后，它本身就只能在内部实例化（new 类名），故它就是单例模式
  15. class Demo1{
  16.     protected function __construct()
  17.     {
  19.     }
  20.     protected static $instance;
  21.     public static function getout(){
  22.         is_null(static::$instance) ? static::$instance=new self() : '';
  23.         //也可以用下面的方法
  24.         // if(is_null(static::$instance)){
  25.         //     static::$instance=new self();
  26.         // }
  27.         return static::$instance;
  28.     }
  29. }
  30. $obj1 = Demo1::getout();
  31. $obj2 = Demo1::getout();
  32. var_dump($obj1 === $obj2);
  33. echo '<br>';
  34. var_dump($obj1, $obj2);
  35. echo '<hr>';
  37. //单例模式应用场景 连接数据库
  38. class Db{
  39.     private static $pdo = null;
  40.     public static function getDate(...$connectParam){
  41.         //这里类实例化new self(...$connectParam), 就是为了把它传参给构造方法
  42.         //is_null是为了验证第一行的$pdo是否被实例化，没有就实例化并传参给构造方法
  43.         is_null(static::$pdo) ? new self(...$connectParam) : '';
  44.         return static::$pdo;
  45.     }
  46.     protected function __construct(...$connectParam){
  47.         $dsn = $connectParam[0];
  48.         $user = $connectParam[1];
  49.         $password = $connectParam[2];
  50.         static::$pdo = new PDO($dsn,$user,$password);
  51.     }
  52.     //禁止使用克隆魔术
  53.     public function __clone()
  54.     {
  56.     }
  57. }
  58. $connectParam = ['mysql:host=localhost;dbname=film', 'root', 'root'];
  59. $pdo = Db::getDate(...$connectParam);
  60. print_r($pdo);
  61. //查询数据库内容，也可以用query()
  62. print_r($pdo->query('SELECT * FROM `movies`')->fetchAll(PDO::FETCH_ASSOC));

工厂模式

  1. <?php
  2. namespace _1205;
  3. class demo2{
  4.     //...
  5. }
  6. // file1.php
  7. $obj = new Demo2();
  8. // file2.php
  9. $obj = new Demo2();
  10. // file3.php
  11. $obj = new Demo2();
  13. //这样调用每次都要实例化一次，很麻烦，故采用工厂模式比较方便
  15. //工厂模式 implode() 将数组转换成字符串
  17. class text1{
  18.     public function __construct($arg1)
  19.     {
  20.         echo '对象1=' . $arg1;
  21.     }
  22. }
  24. class text2{
  25.     public function __construct($arg1, $arg2)
  26.     {
  27.         echo '对象2=' . implode(', ', [$arg1, $arg2]);
  28.     }
  29. }
  31. class text3{
  32.     public function __construct($arg1, $arg2, $arg3)
  33.     {
  34.         echo '对象3=' . implode(', ', [$arg1, $arg2, $arg3]);
  35.     }
  36. }
  38. //使用工厂模式，专门创建类实例/对象
  39. class Factory{
  40.     public static function create($classname, ...$argments){
  41.         return new $classname(...$argments);
  42.     }
  43. }
  44. // 类名::class 完整的类名，命名空间
  45. Factory::create(text1::class, 100);
  46. echo '<br>';
  47. Factory::create(text2::class, 100,200);
  48. echo '<br>';
  49. Factory::create(text3::class, 100,200,300);

依赖注入

  1. <?php
  2. // 依赖注入：解决对象
  4. // 工作类
  5. class Person{
  6.     //要依赖的外部对象
  7.     private $car = null;
  8.     public function __construct()
  9.     {
  10.         //在构造方法中将外部对象全部实例化
  11.         //注入点在构造方法中
  12.         $this->car = new Car();
  13.     }
  14.     public function work(){
  15.         return $this->car->drive();
  16.     }
  17. }
  19. // 依赖的外部类
  20. class car{
  21.     public function drive(){
  22.         return '开车上班';
  23.     }
  24. }
  26. // 客服端实例化
  27. $person = new Person();
  28. echo $person->work();
  29. echo '<hr>';
  31. /*******************************************/
  32. // 最傻瓜的依赖输入方式二
  33. class Person1{
  34.     private static $car = null;
  35.     public function __construct(Car1 $car1)
  36.     {
  37.         static::$car = $car1;
  38.     }
  39.     public function work(){
  40.         return static::$car->drive();
  41.     }
  42. }
  44. class Car1{
  45.     public function drive(){
  46.         return '开皮卡去上班';
  47.     }
  48. }
  50. $car1 = new Car1();
  51. $person1 = new Person1($car1);
  52. echo $person1->work();

自动连接 autoload.php

  1. <?php
  2. spl_autoload_register(function ($className){
  3.     $path = str_replace('\\', '/', $className);
  4.     require dirname(__DIR__) . DIRECTORY_SEPARATOR . $path . '.php';
  5. });

工厂模式小案例

  1. <?php
  2. namespace demo;
  3. use demo\Vehicle\car;
  4. use demo\Vehicle\bus;
  5. use demo\Vehicle\ship;
  7. require __DIR__ . '/autoload.php';
  8. // 工厂类, 专用于创建类实例
  9. class Factroy{
  10.     protected static $intance = null;
  11.     public static function getDrive($variable){
  12.         switch ($variable) {
  13.             case 'car':
  14.                 static::$intance = new car();
  15.                 break;
  16.             case 'bus':
  17.                 static::$intance = new bus();
  18.                 break;
  19.             case 'ship':
  20.                 static::$intance = new ship();
  21.                 break;
  22.         }
  23.         // 返回当前具体的交通工具
  24.         return static::$intance;
  25.     }
  26. }
  28. class drive{
  29.     // 交通工具
  30.     protected static $vehicle;
  31.     // 构造方法 调用工厂，传参
  32.     public function __construct($variable)
  33.     {
  34.         static::$vehicle = Factroy::getDrive($variable);
  35.     }
  36.     // 调用外部一个依赖对象
  37.     public function trave(){
  38.         return static::$vehicle->drive() . ' 美好生活';
  39.     }
  40. }
  41. //客户端输出
  42. echo (new drive('ship'))->trave() . '<br>';
  43. echo (new drive('car'))->trave() . '<br>';
  44. echo (new drive('bus'))->trave() . '<br>';
  45. //#外部类################
  46. //#外部类################
  47. //#外部类################
  48. <?php
  49. namespace demo\Vehicle;
  50. class bus{
  51.     public function drive(){
  52.         return '坐公交车';
  53.     }
  54. }
  55. ===============================
  56. <?php
  57. namespace demo\Vehicle;
  58. class car{
  59.     public function drive(){
  60.         return '开汽车';
  61.     }
  62. }
  63. ===============================
  64. <?php
  65. namespace demo\Vehicle;
  66. class ship{
  67.     public function drive(){
  68.         return '坐轮船';
  69.     }
  70. }

接口类 代替 工厂模式

  1. <?php
  2. namespace demo;
  4. use demo\Vehicle\train;
  5. use demo\Vehicle\plane;
  6. use demo\Vehicle\iVehicle;
  8. require __DIR__ . '/autoload.php';
  10. class travee{
  11.     // 交通工具
  12.     private static $vehicle;
  14.     // 构造方法
  15.     public function __construct(iVehicle $vehicle)
  16.     {
  17.         static::$vehicle = $vehicle;
  18.     }
  20.     // 调用外部一个依赖对象
  21.     public function go()
  22.     {
  23.         return static::$vehicle->drive() . ' : ======= 去旅行';
  24.     }
  25. }
  26. //客户端调用
  27. echo (new travee(new plane()))->go(),'<br>';
  28. echo (new travee(new train()))->go();
  29. //#####################
  30. //#####################
  31. //#####################
  32. <?php
  33. namespace demo\Vehicle;
  34. //接口
  35. interface iVehicle{
  36.     public function drive();
  37. }
  38. ===========================
  39. <?php
  40. namespace demo\Vehicle;
  42. class plane implements iVehicle{
  43.     public function drive(){
  44.         return '坐飞机';
  45.     }
  46. }
  47. ===========================
  48. <?php
  49. namespace demo\Vehicle;
  51. class train implements iVehicle{
  52.     public function drive(){
  53.         return '坐火车';
  54.     }
  55. }

总结

本节课相对简单，今天好好做了一次，基本掌握了

上一条：PHP第18课-类静态后期绑定与MVC-九期线上班下一条：自己搞了一天DB类 修改了一些东西 终于成功了
声明：本文内容转载自脚本之家，由网友自发贡献，版权归原作者所有，如您发现涉嫌抄袭侵权，请联系admin@php.cn 核实处理。
全部评论
文明上网理性发言，请遵守新闻评论服务协议

相关文章

查看更多