Community Learn Tools Library Leisure
search
English
Home > List of blog posts > 12月5日作业--php培训九期线上班
Blogger Information
Blog 33
fans 0
comment 0
visits 19823
Special Recommendation
More>
Related recommendations
Popular Tutorials
More>
Related Tutorials
Popular Recommendations
Latest courses
Latest Downloads
More>
Web Effects
Website Source Code
Website Materials
Front End Template
12月5日作业--php培训九期线上班
取个名字真难
Original
413 people have browsed it

单例模式

  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);

总结

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

Correcting teacher：天蓬老师天蓬老师

Correction status：qualified

Teacher's comments：画出流程图, 辅助理解, 这些都是项目开发中, 最基本的知识点, 必须明白
Statement of this Website
The copyright of this blog article belongs to the blogger. Please specify the address when reprinting! If there is any infringement or violation of the law, please contact admin@php.cn Report processing!
All comments Speak rationally on civilized internet, please comply with News Comment Service Agreement
0 comments
Author's latest blog post