search

博客列表 >12月5日作业--php培训九期线上班

12月5日作业--php培训九期线上班

取个名字真难
取个名字真难原创
2019年12月08日 16:19:47412浏览

单例模式

  1. <?php
  2. namespace _1205;
  3. //use PDO;
  4. // 单例模式
  5. class Temp
  6. {
  7.     // ...
  8. }
  10. $obj1 = new Temp();
  11. $obj2 = new Temp();
  12. var_dump($obj1, $obj2);
  13. echo '<br>';
  14. var_dump($obj1 === $obj2);
  15. echo '<hr>';
  17. // 单例模式原理
  18. class Demo1
  19. {
  20.     // 构造方法私有化
  21.     private function __construct()
  22.     {
  23.     }
  25.     // 目前 只能在类中的内部将类实例化
  26.     // 当前类的实例
  27.     public static $instance = null;
  29.     // 实例化当前类的方法
  30.     public static function getInstance()
  31.     {
  32.         // 实例化当前类,并返回类实例/对象
  33.         // 判断当前类是否已经被实例化过了,如果没有的话就实例化,如果已实例化,就返回它
  34.         if (is_null(self::$instance)) {
  35.             self::$instance = new self();
  36.         }
  38.         return self::$instance;
  39.     }
  41.     // 禁用克隆魔术方法
  42.     private function __clone()
  43.     {
  44.         // ...
  45.     }
  46. }
  48. //new Demo1();
  49. $obj1 = Demo1::getInstance();
  50. $obj2 = Demo1::getInstance();
  51. var_dump($obj1 === $obj2);
  52. echo '<br>';
  53. var_dump($obj1, $obj2);
  54. echo '<hr>';
  56. // 单例模型应用场景数据库链接
  57. class Db
  58. {
  59.     // 构造方法私有化
  60.     private function __construct(...$connectParams)
  61.     {
  62.         $dsn = $connectParams[0];
  63.         $username = $connectParams[1];
  64.         $password = $connectParams[2];
  66.         self::$pdo = new \PDO($dsn, $username, $password);
  67.     }
  69.     // 目前 只能在类中的内部将类实例化
  70.     // 当前类的实例
  71.     public static $pdo = null;
  73.     // 实例化当前类的方法
  74.     public static function getInstance(...$connectParams)
  75.     {
  76.         // 实例化当前类,并返回类实例/对象
  77.         // 判断当前类是否已经被实例化过了,如果没有的话就实例化,如果已实例化,就返回它
  78.         if (is_null(self::$pdo)) {
  79.             // 构造函数不需要返回
  80.             new self(...$connectParams);
  81.         }
  83.         return self::$pdo;
  84.     }
  86.     // 禁用克隆魔术方法
  87.     private function __clone()
  88.     {
  89.         // ...
  90.     }
  91. }
  92. echo '<hr>';
  93. $connectParams = ['mysql:host=localhost;dbname=mysql', 'root', 'root'];
  94. $pdo = Db::getInstance(...$connectParams);
  96. print_r($pdo->query('SELECT * FROM `db`')->fetchAll());

工厂模式

  1. <?php
  2. //工床模式
  3. class Test1
  4. {
  5.     public function __construct($arg1)
  6.     {
  7.         echo '对象创建成功, 参数是: ' . $arg1;
  8.     }
  9. }
  11. class Test2
  12. {
  13.     public function __construct($arg1, $arg2)
  14.     {
  15.         echo '对象创建成功, 参数是: ' . implode(', ', [$arg1, $arg2]);
  16.     }
  17. }
  19. class Test3
  20. {
  21.     public function __construct($arg1, $arg2, $arg3)
  22.     {
  23.         echo '对象创建成功, 参数是: ' . implode(', ', [$arg1, $arg2, $arg3]);
  24.     }
  25. }
  27. // 工厂类, 专用于创建类实例
  28. class Factory
  29. {
  30.     public static function create($className, ...$argments)
  31.     {
  32.         return new $className(...$argments);
  33.     }
  34. }
  37. // 用工厂类来创建类实例/对象
  38. Factory::create(Test1::class, 500);
  39. echo '<br>';
  40. Factory::create(Test2::class,'第一个参数','第二个参数');
  41. echo '<br>';
  42. Factory::create(Test3::class, '第一个参数','第二个参数','第三个参数');

依赖注入

  1. <?php
  2. //依赖注入
  3. namespace dem;
  4. //创建类
  5. class Person
  6. {
  7. //    要依赖的外部对象
  8. private  $car;
  9. //在构造方法中将依赖的外部对象 全部实例化
  10. public  function __construct()
  11. {
  12.     $this->car=new Car();
  13. }
  15. //外部对象的方法
  16. public  function  work()
  17. {
  18.     return $this->car->drive();
  19. }
  20. }
  22. //依赖外部的类
  23. class Car
  24. {
  25. //    外部类的方法
  26.     public function drive()
  27.     {
  28.         return '开车去上工作';
  29.     }
  30. }
  32. //实例化类
  33. $Person=new Person();
  34. echo $Person->work();
  35. echo '<hr>';
  39. class Person1
  40. {
  41.     // 要依赖的外部对象
  42.     private $car ;
  44.     // 在构造方法中将依赖的外部对象全部实例化
  45.     // 注入点放到构造方法中
  46.     public function __construct(Car $car)
  47.     {
  48.         $this->car = $car;
  49.     }
  51.     // 外部对象执行一个动作
  52.     public function work()
  53.     {
  54.         return $this->car->drive();
  55.     }
  56. }
  58. // 依赖的外部类
  59. class Car1
  60. {
  61.     public function drive()
  62.     {
  63.         return '开车去上班';
  64.     }
  65. }
  67. // 实例化类
  68. $car = new Car();
  69. $person = new Person1($car);
  70. echo $person->work();
  71. echo '<hr>';

namespace base\inc1\car;

  1. <?php
  2. namespace base\inc1;
  4. class Car
  5. {
  6.     public function drive()
  7.     {
  8.         return '开汽车';
  9.     }
  10. }

namespace base\inc1\plane;

  1. <?php
  2. namespace base\inc1;
  3. class Plane{
  4.     public function  drive()
  5.     {
  6.         return '坐***';
  7.     }
  8. }

namespace base\inc1\train;

  1. <?php
  2. namespace base\inc1;
  3. class Train{
  4.     public function drive()
  5.     {
  6.         return '坐火车';
  7.     }
  8. }

namespace base\travel1.php;

  1. <?php
  2. //***类
  3. namespace  base;
  5. //引用类
  6. use base\inc1\Car;
  7. use base\inc1\Train;
  8. use base\inc1\Plane;
  10. require __DIR__ .'/autoload.php';
  11. class Travel1
  12. {
  13. //    交通工具
  14.     private  $vehicle;
  15. //    构造方法
  16. public  function __construct($vehicle)
  17. {
  18.     switch (strtolower($vehicle)){
  19.         case 'car';
  20.         $this->vehicle=new Car();
  21.         break;
  22.         case 'train';
  23.         $this->vehicle=new Train();
  24.         break;
  25.         case 'plane';
  26.         $this->vehicle=new Plane();
  27. break;
  29.     }
  30. }
  31. //调用外部一个对象
  32. public  function travelModel()
  33. {
  34.     return $this->vehicle->drive().'去玩耍';
  35. }
  37. }
  38. //客户端调用
  39. echo  (new Travel1('car'))->travelModel() . '<br>';
  40. echo  (new Travel1('train'))->travelModel() . '<br>';
  41. echo  (new Travel1('plane'))->travelModel() . '<br>';

namespace base\travel1.php;

  1. <?php
  2. // ***类: 使用最传统的方式
  4. namespace base;
  6. // 设置引用的外部类名的别名
  7. use base\inc1\Car;
  8. use base\inc1\Train;
  9. use base\inc1\Plane;
  11. require __DIR__ . '/autoload.php';
  13. // 工厂类, 专用于创建类实例
  14. class Factory
  15. {
  16.     protected static $instance = null;
  18.     public static function getInstance($vehicle)
  19.     {
  20. //判断是哪种交通工具
  21.         switch (strtolower($vehicle)) {
  22.             case 'car':
  23.                 self::$instance = new Car();
  24.                 break;
  25.             case 'train':
  26.                 self::$instance = new Train();
  27.                 break;
  28.             case 'plane':
  29.                 self::$instance = new Plane();
  30.         }
  32.         // 返回当前具体的交通工具
  33.         return self::$instance;
  34.     }
  35. }
  38. class Travel2
  39. {
  40.     // 交通工具
  41.     private $vehicle;
  43.     // 构造方法
  44.     public function __construct($vehicle)
  45.     {
  46.         $this->vehicle = Factory::getInstance($vehicle);
  47.     }
  49.     // 调用依赖对象
  50.     public function travelModel()
  51.     {
  52.         return $this->vehicle->drive() . ' : @@@@  去***';
  53.     }
  54. }
  56. // 客户端调用
  57. echo  (new Travel2('car'))->travelModel(). '<br>';
  58. echo  (new Travel2('train'))->travelModel(). '<br>';
  59. echo  (new Travel2('plane'))->travelModel(). '<br>';

接口

  1. <?php
  3. namespace base\inc1;
  5. // 交通工具的接口
  6. interface iVehicle
  7. {
  8.     public function drive();
  9. }

ravel3.php

  1. <?php
  2. // ***类: 使用最传统的方式
  4. namespace base;
  6. // 设置引用的外部类名的别名
  7. use base\inc1\Car;
  8. use base\inc1\Train;
  9. use base\inc1\Plane;
  10. use base\inc1\Ship;
  11. use base\inc1\iVehicle;
  14. require __DIR__ . '/autoload.php';
  17. class Travel3
  18. {
  19.     // 交通工具
  20.     private $vehicle;
  22.     // 构造方法
  23.     public function __construct(iVehicle $vehicle)
  24.     {
  25.         $this->vehicle = $vehicle;
  26.     }
  28.     // 调用外部一个依赖对象
  29.     public function travelModel()
  30.     {
  31.         return $this->vehicle->drive() . ' : ======= 去***';
  32.     }
  33. }
  35. // 客户端调用
  36. $car = new Car();
  37. echo  (new Travel3($car))->travelModel(), '<br>';
  41. echo  (new Travel3(new Train()))->travelModel(), '<br>';
  42. echo  (new Travel3(new Plane()))->travelModel(), '<br>';
  45. echo  (new Travel3(new Ship()))->travelModel(), '<br>';

Container

  1. <?php
  2. //容器类
  3. namespace _1205;
  4. //引用闭包
  5. use Closure;
  7. class  Container
  8. {
  9. //    类实例
  10. protected  $instance=[];
  11. //将实例化过程绑定到容中
  12. public  function bind($alias, Closure $process)
  13. {
  14.     $this->instance[$alias]=$process;
  15. }
  16. //取出保存在容器中的实例化过程
  17. public  function maker($alias)
  18. {
  19.     return $this->instance[$alias];
  20. }
  21. }

Maker

  1. <?php
  2. namespace _1205;
  4. class Maker
  5. {
  6.     public  function get()
  7.     {
  8.         return '华为';
  9.     }
  10. }

Product

  1. <?php
  2. namespace _1205;
  4. class Product {
  5.     public  function get(Maker $maker)
  6.     {
  7.         return '该手机是由：'.$maker->get().'生产的';
  8.     }
  9. }

deomo1

  1. <?php
  2. require 'Product.php';
  3. require 'Maker.php';
  5. class  Client1
  6. {
  7. //    直接输出
  8. public  function  show(){
  9.     $product=new \_1205\Product();
  11.     $make=new \_1205\Maker();
  12.     return $product->get($make);
  13. }
  14. }
  15. // 调用
  16. echo  (new Client1())->show();
  17. $sh=new Client1();
  18. echo $sh->show();

demo2

  1. <?php
  2. namespace _1205;
  4. require 'Product.php';
  5. require 'Maker.php';
  6. require 'Container.php';
  7. // 不用容器
  8. class Client2
  9. {
  10.     // 直接输出商品与制造商
  11.     public function show(Product $product, Maker $maker)
  12.     {
  13.         // 制造商注入到产品类中
  14.         return $product->get($maker);
  15.     }
  16. }
  18. // 绑定到容器中并实例化且返回
  19. $container = new Container();
  20. // 将实例化代码绑定到容器中
  21. $container->bind('product', function () {return new Product();});
  22. $container->bind('maker', function () {return new Maker();});
  23. // 创建类实例并返回
  24. $product = $container->maker('product');
  25. $maker = $container->maker('maker');
  29. echo  (new Client2())->show($product, $maker);

总结

我个人对这些依赖注入、工厂类、接口、容器啥的理解就是都是围绕这个类来的，然后在这些类就像函数哪样来调用，各自完成应用的功能，然后再把这些功能进行衔接，这些单个理解起来还是很容易的就是要完整的组合起来理解 在这些中调来调去的 还没看完就已经绕晕了。

上一条：11月29日- 抽象类和接口下一条：1205_依赖注入和服务容器复习及设计模式 第29课
声明：本文内容转载自脚本之家，由网友自发贡献，版权归原作者所有，如您发现涉嫌抄袭侵权，请联系admin@php.cn 核实处理。
全部评论
文明上网理性发言，请遵守新闻评论服务协议

相关文章

查看更多