PHP 第课 将课堂代码全部上机操作至少一遍以上 12月5日作业

作业一

Demo1.php单利模式
` <?php

//单例模式
namespace _1205;
class Temp
{
    //
}
$obj1 = new Temp();
$obj2 = new Temp();
var_dump($obj1,$obj2);
//单例模式原理
class Demo1
{
    //构造方发私有化
    private function __construct()
    {
    }
//    目前 只能在类中的背部将类实例化
//  当前类的实例
    public static $instace = null;
    //实例化当前类的方法
    public static function getInstance()
    {
        //实例化当前类，并返回类实例/对象
//        判断当前类是否已经被实例化过了，如果没有的化就实例化，如果以实例化，就返回它
        if(is_null(self::$instace)){
            self::$instace = new self;
        }
        return self::$instace;
    }
//    禁用克隆魔术方法
    private function __clone()
    {
    }
}
//new Demo1();
$obj1 = Demo1::getInstance();
$obj2 = Demo1::getInstance();
var_dump($obj1 === $obj2);
echo '<hr>';
var_dump($obj1,$obj2);//解决重复实例化
//单利模型应用场景
class Db
{
    //构造方发私有化
    private function __construct(...$connectParams)
    {
        $dsn = $connectParams[0];
        $username = $connectParams[1];
        $password = $connectParams[2];
        self::$pdo = new \PDO($dsn,$username,$password);
    }
//    目前 只能在类中的背部将类实例化
//  当前类的实例
    public static $pdo = null;
    //实例化当前类的方法
    public static function getInstance(...$connectParams)
    {
        //实例化当前类，并返回类实例/对象
//        判断当前类是否已经被实例化过了，如果没有的化就实例化，如果以实例化，就返回它
        if(is_null(self::$pdo)){
//            构造函数不需要返回
             new self(...$connectParams);
        }
        return self::$pdo;
    }
//    禁用克隆魔术方法
    private function __clone()
    {
    }
}
echo '<hr>';
//连接数据库
$connectParams = ['mysql:host=127.0.0.1;dbname=pdo','root','root'];
$pdo = Db::getInstance(...$connectParams); //使用php7 新特性
//使用查询数据库select
print_r($pdo ->query('SELECT * FROM `users`')->fetchAll());`

Demo2.php 工厂模式
<?php

namespace _1205;
//工厂模式： 用于批量创建类的实例/ 对象
use _1204\Db2;
class Demo2
{
    //....
}
//file1.php
$obj = new Demo2();
//file3.php
$obj = new Demo2();
//file3.php
$obj = new Demo2();
//+++++++++++++++++++++++++++++++++++++++++++
//创建类
class Test1
{
//    创建构造方法
    public function __construct($agr1)
    {
        echo '对象创建成功，参数是: ' . $agr1;
    }
}
//创建类
class Test2
{
//    创建方法
    public function __construct($agr1,$arg2)
    {
        echo '对象创建成功，参数是: ' . implode(',',[$agr1,$arg2]);
    }
}
class Test3
{
    public function __construct($agr1,$arg2,$agr3)
    {
        echo '对象创建成功，参数是: ' . implode(',',[$agr1,$arg2,$agr3]);
    }
}
//工厂类，专门创建类实例
class  Factory
{
    public static function cerate($className,...$argments)
    {
        return new $className(...$argments);
    }
}
echo Test::class;//_1205\Test: 完整的类名，代用命名空间的
//用工厂类来创建类实例
Factory::cerate(Test1::class,100);
echo '<br>';
Factory::cerate(Test2::class,.100,200);
echo '<br>';
Factory::cerate(Test3::class,.100,200,300);

Demo3.php依赖注入
<?php
//依赖注入： 解决对象调用之间耦合

//工作类
class Person
{
//    要依赖的外部对象
    private $car = null;
    //在构造方法中将依赖的外部对象全部实例化
//    注入点放到构造方法中
    public function __construct()
    {
        $this->car = new Car();
    }
    //对外部对象执行一个动作
    public function work()
    {
        return $this->car->drive();
    }
}
//依赖的外部类
class Car
{
    public function drive()
    {
        return '开车去上班';
    }
}
//实例化类
$person = new Person();
echo $person->work();
echo '<hr>';
/*********************************************/
class Person1
{
//    要依赖的外部对象
    private $car = null;
    //在构造方法中将依赖的外部对象全部实例化
//    注入点放到构造方法中
    public function __construct(Car $car)
    {
        $this->car = $car;
    }
    //对外部对象执行一个动作
    public function work()
    {
        return $this->car->drive();
    }
}
//依赖的外部类
class Car1
{
    public function drive()
    {
        return '开车去上班';
    }
}
//实例化类
$car = new Car();
$person = new Person1($car);
echo $person->work();
echo '<hr>';

base\Travel1.php
<?php
//旅行类: 使用最传统的方式

namespace base;
//设置引用的外部类名的别名
use base\inc1\Car;
use base\inc1\Train;
use base\inc1\Plane;
//导入绝对的路径自动加载
require __DIR__.'/autoload.php';
//创建类
class Travel1
{
    //交通工具
    private $vehicle;
    //构造方法
    public function __construct($vehicle)
    {
//       用switch判断下条件 用构造方法进行初始化
        switch(strtolower($vehicle)){
            case 'car':
                $this->vehicle = new Car(); //初始化成员后 = 实例化Car()方法
                break;
            case 'train':
                $this->vehicle = new Train();
                break;
            case 'plane':
                $this->vehicle = new Plane();
        }
    }
//    创建去哪里玩耍模型控制器
    public function travelModel()
    {
//        返回本类中 构造初始化 -》 inc1中的三个方法
        return $this->vehicle->drive(). ': 去旅行';
    }
}
//客户端调用  实例化car方法 -》抵用 travaelMidel 模板信息
echo (new Travel1('car'))->travelModel(), '</br>';
echo (new Travel1('train'))->travelModel(),'</br>';
echo (new Travel1('plane'))->travelModel().'<br>';

base\Travel2.php
<?php
//旅行类: 使用最传统的方式

namespace base;
//设置引用的外部类名的别名
use base\inc1\Car;
use base\inc1\Train;
use base\inc1\Plane;
//导入绝对的路径自动加载
require __DIR__.'/autoload.php';
//工厂类 : 专用于创建类实例
class Factory
{
//    将工厂类成员静态化
    protected static $instance = null;
    public static function getInstance($vehicle)
    {
        switch(strtolower($vehicle)){
            case 'car':
                self::$instance = new Car();
                break;
            case 'train':
                static::$instance = new Train();
                break;
            case 'plane':
                static::$instance = new Plane();
        }
        //返回当前具体的交通工具
        return static::$instance;
    }
}
//1、创建类
class Travel2
{
    //交通工具
    private $vehicle;
    //构造方法
    public function __construct($vehicle)
    {
//        用构造方法进行初始化
        $this->vehicle = Factory::getInstance($vehicle);
    }
    //    创建去哪里玩耍模型控制器
    public function travelModel()
    {
//        返回 本类调用初始化 -》调用是三个值
        return $this->vehicle->drive(). ': @@@@去旅行';
    }
}
//客户端调用    实例化car方法 -》抵用 travaelMidel 模板信息
echo (new Travel2('car'))->travelModel(), '</br>';
echo (new Travel2('train'))->travelModel(),'</br>';
echo (new Travel2('plane'))->travelModel().'<br>';

base\Travel3.php
<?php
//旅行类: 使用最传统的方式

namespace base;
//设置引用的外部类名的别名
use base\inc2\Car;
use base\inc2\Train;
use base\inc2\Plane;
use base\inc2\Ship;
use base\inc2\iVehicle; // 使用类
//调用绝对路径自动加载
require __DIR__.'/autoload.php';
//创建类
class Travel3
{
    //交通工具
    private $vehicle;
    //构造方法 : 使用了接口给对象类 变得更加的灵活
    public function __construct(iVehicle $vehicle)
    {
//        初始化交通工具
        $this->vehicle = $vehicle;
    }
//    创建类方法 去哪里玩耍
    public function travelModel()
    {
//        返回   调用本类的构造方法 然后调用接口中的统一方法  function drive()
        return $this->vehicle->drive(). ': ++++++++++++++去旅行';
    }
}
//客户端调用   接口实现了统一方法，让代码更加简洁
echo (new Travel3(new Car()))->travelModel(), '</br>';
echo (new Travel3(new Train()))->travelModel(),'</br>';
echo (new Travel3(new Plane()))->travelModel().'<br>';
echo (new Travel3(new Ship()))->travelModel().'<br>';

1205/lesson1/Container.php
<?php

//容器类
namespace _1205;
use Closure;
//创建容器类
class Container
{
    //类实例容器
    protected $instance = [];
    //将类实例化的过程绑定到容器中
    public function bind($alias,Closure $process)
    {
        $this->instance[$alias] = $process;
    }
//    去除保存在容器中的实例化过程的闭包，并执行它
        public function make($alias)
        {
//            返回  本类实例容器中
            return $this->instance[$alias]();
        }
}

1205/lessonl/demo1.php
<?php

namespace _1205;
require 'Product.php';
require  'Maker.php';
//先不用容器
class Client1
{
    //输出商品与制造商
    public  function show()
    {
        //创建产品的实例
        $product = new Product();
        //创建制造商的实例
        $maker = new Maker();
        //制造商注入到产品类中
        return  $product->get($maker);
    }
}
//客户端调用
echo (new Client1())->show();

作业二

总结

1、单利模式只能实例化一个类，相同的方法可以用接口， 工厂模式可以实例化多个对象

2、创建容器后必须创建类成员（类实例容器） protected $inser = []; 还要使用use 类

3、spl_autoload_register() 方法将路拼接封装，实现自动加载文件

4、如果每天努力的完成任务也就不会那么多的作业，不应该相信有周六、周天，大把的时间，这两天是用来复习学习过的知识！
5、用自己的方法去写注释，发现很多都很写出来，自己不能写出来，可能是写的太少了，也知道了自己的不足！