设计模式-php实现

最新推荐文章于 2024-07-07 23:15:22 发布
最新推荐文章于 2024-07-07 23:15:22 发布
阅读量320 收藏
点赞数
分类专栏： 设计模式 文章标签： 设计模式 php 代码
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_21429395/article/details/90292300
版权

前言

在实现具体的模式前，我想说大家应该了解的的一些php基础，先来复习几个小问题：

  1. 抽象类：

    是指在 class 前加了 abstract 关键字且存在抽象方法（在类方法 function 关键字前加了 abstract 关键字）的类。抽象类不能被直接实例化。抽象类中只定义（或部分实现）子类需要的方法。
    子类可以通过继承抽象类并通过实现抽象类中的所有抽象方法，使抽象类具体化。如果子类需要实例化，前提是它实现了抽象类中的所有抽象方法。如果子类没有全部实现抽象类中的所有抽象方法，那么该子类也是一个抽象类，必须在 class 前面加上 abstract 关键字，并且不能被实例化。
    注意：
    抽象类 抽象方法 B()，那么 继承该抽象类 实现B() 方法的访问控制不能比 抽象类 抽象方法 B() 的访问控制更严格，也就是说：抽象类 抽象方法 B() 不能为Private 最少为Protected；

  2. Interface(接口)

    接口用关键字 interface 来声明。抽象类提供了具体实现的标准，而接口则是纯粹的模版。接口只定义功能，而不包含实现的内容。
    interface 是完全抽象的，只能声明方法，而且只能声明 public 的方法，不能声明 private 及 protected的方法，不能定义方法体，也不能声明实例变量 。然而， interface 却可以声明常量变量 。但将常量变量放在 interface中违背了其作为接口的作用而存在的宗旨，也混淆了 interface 与类的不同价值。如果的确需要，可以将其放在相应的 abstractclass 或 Class 中。任何实现接口的类都要实现接口中所定义的所有方法，否则该类必须声明为 abstract。一个类可以在声明中使用 implements关键字来实现某个接口。这么做之后，实现接口的具体过程和继承一个仅包含抽象方法的抽象类是一样的。一个类可以同时继承一个父类和实现任意多个接口。extends 子句应该在 implements 子句之前。
    PHP 只支持继承自一个父类，因此 extends关键字后只能跟一个类名。接口不可以实现另一个接口，但可以继承多个。

  3. Abstract Class与Interface的异同相同点

    相同点：
    (a)两者都是抽象类，都不能实例化。
    (b)interface实现类及 abstract class 的子类都必须要实现已经声明的抽象方法。
    不同点：
    (a)interface 需要实现，要用implements ，而 abstract class 需要继承，要用 extends 。 一个类可以实现多个 interface
    ，但一个类只能继承一个 abstract class 。
    (b)interface 强调特定功能的实现，而 abstract class强调所属关系。
    ©尽管 interface 实现类及 abstract class的子类都必须要实现相应的抽象方法，但实现的形式不同。 interface 中的每一个方法都是抽象方法，都只是声明的(declaration, 没有方法体 ) ，实现类必须要实现。
    (d)而 abstract class 的子类可以有选择地实现。这个选择有两点含义：
    abstract class 中并非所有的方法都是抽象的，只有那些冠有 abstract 的方法才是抽象的，子类必须实现。那些没有 abstract 的方法，在 abstract class 中必须定义方法体；
    abstract class 的子类在继承它时，对非抽象方法既可以直接继承，也可以覆盖；而对抽象方法，可以选择实现，也可以留给其子类来实现，但此类必须也声明为抽象类。既是抽象类，当然也不能实例化。
    abstract class 是 interface 与 class 的中介。 abstract class 在 interface 及 class 中起到了承上启下的作用。一方面， abstract class 是抽象的，可以声明抽象方法，以规范子类必须实现的功能；另一方面，它又可以定义缺省的方法体，供子类直接使用或覆盖。另外，它还可以定义自己的实例变量，以供子类通过继承来使用。
    接口中的抽象方法前不用也不能加 abstract 关键字，默认隐式就是抽象方法，也不能加 final 关键字来防止抽象方法的继承。而抽象类中抽象方法前则必须加上 abstract 表示显示声明为抽象方法。
    接口中的抽象方法默认是 public 的，也只能是 public 的，不能用 private ， protected 修饰符修饰。而抽象类中的抽象方法则可以用 public ， protected 来修饰，但不能用 private 。
    废话一大堆 下边进入正题！
    一、设计原则
    1、找出应用中可能存在变化的部分并独立出来，不要和不变化的代码混在一起；
    2、针对接口编程而不是针对实现编程；
    在这里插入图片描述

3、多用组合，少用继承；
4、为了交互对象间松耦合设计努力；
5、类应该对扩展开发，修改关闭，即开发-关闭原则；
6、…

二、策略模式
1、定义：策略模式(Strategy Pattern)：定义一系列算法，将每一个算法封装起来，并让它们可以相互替换。策略模式让算法独立于使用它的客户而变化，也称为政策模式(Policy)。
2、模式动机：完成一项任务，往往可以有多种不同的方式，每一种方式称为一个策略，我们可以根据环境或者条件的不同选择不同的策略来完成该项任务。
3、角色分析：
　　抽象策略角色：策略类，通常由一个接口或者抽象类实现。
　　具体策略角色：包装了相关的算法和行为。
　　环境角色：持有一个策略类的引用，最终给客户端调用。
4、代码实现：

<?php
/**
 * Created by PhpStorm.
 * User: lenovo
 * Date: 2019/2/21
 * Time: 15:42
 */
header("Content-type:text/html;Charset=utf-8");

// 策略模式

//抽象策略接口
abstract class Human
{
    abstract function life();
    //愿意实现啥再写点啥呗 ......
}

//具体策略角色
class ManStrategy extends Human
{
    function life()
    {
        echo "赚钱养家";
    }
}

class WomanStrategy extends Human
{
    function life()
    {
        echo "貌美如花";
    }
}

// 愿意多几个算法.....

//环境角色
class Context
{
    private $strategy;

    //获取具体策略
    function getStrategy($strategyName)
    {
        try {
            // ReflectionClass 类报告了一个类的有关信息。
            $strategyReflection = new ReflectionClass($strategyName);
            // ReflectionClass::newInstance 从指定的参数创建一个新的类实例
            // 给出的参数将会传递到类的构造函数。
            $this->strategy = $strategyReflection->newInstance();
        } catch (ReflectionException $e) {
            $this->strategy = "";
        }
    }

    function getLifeStyle()
    {
        $this->strategy->life();
        // var_dump($this->strategy);
    }
}

//测试
$context = new Context();
$context->getStrategy("ManStrategy");
$context->getLifeStyle();
?>

三、观察者模式
1、定义：当对象间存在一对多关系时，则使用观察者模式（Observer Pattern）。比如，当一个对象被修改时，则会自动通知它的依赖对象。观察者模式属于行为型模式。
2、模式动机：一个对象状态改变给其他对象通知的问题，而且要考虑到易用和低耦合，保证高度的协作。
在这里插入图片描述
3、代码实现

<?php
/**
 * Created by PhpStorm.
 * User: lenovo
 * Date: 2019/2/21
 * Time: 15:42
 */
header("Content-type:text/html;Charset=utf-8");

/**
 * 观察者模式 （主题一对多观察者对象）
 * @package design pattern
 */

/**
 * 抽象主题角色
 */
interface Subject
{

    /**
     * 增加一个新的观察者对象
     * @param Observer $observer
     */
    public function attach(Observer $observer);

    /**
     * 删除一个已注册过的观察者对象
     * @param Observer $observer
     */
    public function detach(Observer $observer);

    /**
     * 通知所有注册过的观察者对象
     */
    public function notifyObservers();
}

/**
 * 具体主题角色
 */
class ConcreteSubject implements Subject
{

    private $_observers;

    public function __construct()
    {
        $this->_observers = array();
    }

    /**
     * 增加一个新的观察者对象
     * @param Observer $observer
     */
    public function attach(Observer $observer)
    {
        return array_push($this->_observers, $observer);
    }

    /**
     * 删除一个已注册过的观察者对象
     * @param Observer $observer
     */
    public function detach(Observer $observer)
    {
        $index = array_search($observer, $this->_observers);
        if ($index === FALSE || !array_key_exists($index, $this->_observers)) {
            return FALSE;
        }

        unset($this->_observers[$index]);
        return TRUE;
    }

    /**
     * 通知所有注册过的观察者对象
     */
    public function notifyObservers()
    {
        if (!is_array($this->_observers)) {
            return FALSE;
        }

        foreach ($this->_observers as $observer) {
            $observer->update();
        }

        return TRUE;
    }

}

/**
 * 抽象观察者角色
 */
interface Observer
{

    /**
     * 更新方法
     */
    public function update();
}

/**
 * Class ConcreteObserver
 */
class ConcreteObserver implements Observer
{

    /**
     * 观察者的名称
     * @var <type>
     */
    private $_name;

    public function __construct($name)
    {
        $this->_name = $name;
    }

    /**
     * 更新方法
     */
    public function update()
    {
        echo 'Observer', $this->_name, '已通知成功<br />';
    }

}

/**
 * 主题与观察者都使用接口 观察者利用主题接口向主题注册，
 * 而主题利用观察者接口通知观察者 达到两者不干扰 松耦合
 */
//实例化 具体主题角色 类：
$subject = new ConcreteSubject();

/* 添加第一个观察者 */
$observer1 = new ConcreteObserver('xiaoming');
$subject->attach($observer1);

echo '<br /> 第一个通知:<br />';
$subject->notifyObservers();

/* 添加第二个观察者 */
$observer2 = new ConcreteObserver('xiaoxiao');
$subject->attach($observer2);

echo '<br /> 第二个通知:<br />';
$subject->notifyObservers();

/* 删除第一个观察者 */
$subject->detach($observer1);

echo '<br /> 第三个通知:<br />';
$subject->notifyObservers();

四、装饰者模式
1、定义：装饰器(Decorator)模式就是对一个已有结构增加"装饰"，简单的说就是动态的添加类的功能。（在面向对象的设计中，我们也应该尽量使用对象组合，而不是对象继承来扩展和复用功能。装饰器模式就是基于对象组合的方式，可以实现最大的灵活性 ）
2、模式动机：
模式动机:一般有两种方式可以实现给一个类或对象增加行为：
　　继承机制，使用继承机制是给现有类添加功能的一种有效途径，通过继承一个现有类可以使得子类在拥有自身方法的同时还拥有父类的方法。但是这种方法是静态的，用户不能控制增加行为的方式和时机。
　　关联机制，即将一个类的对象嵌入另一个对象中，由另一个对象来决定是否调用嵌入对象的行为以便扩展自己的行为，我们称这个嵌入的对象为装饰器(Decorator)
装饰模式以对客户透明的方式动态地给一个对象附加上更多的责任，换言之，客户端并不会觉得对象在装饰前和装饰后有什么不同。装饰模式可以在不需要创造更多子类的情况下，将对象的功能加以扩展。这就是装饰模式的模式动机。
3、代码实现：

<?php
/**
 * Created by PhpStorm.
 * User: lenovo
 * Date: 2019/2/21
 * Time: 15:42
 */
header("Content-type:text/html;Charset=utf-8");

// 装饰者模式及php实现

//被装饰者基类
interface Component
{
    function operation();
}

//具体被装饰者类
class ConcreteComponent implements Component
{
    function operation()
    {
        echo "加了被装饰者";
    }
}

//装饰者基类
abstract class Decorator implements Component
{
    private $component;

    function __construct($component)
    {
        $this->component = $component;
    }

    //override
    function operation()
    {
        $this->component->operation();
    }
}

//具体装饰类A
class ConcreteDecoratorA extends Decorator
{
    public function __construct(Component $component)
    {
        parent::__construct($component);

    }

    public function operation()
    {
        parent::operation();
        $this->addedOperationA();   //  新增加的操作
    }

    public function addedOperationA()
    {
        echo "，又加了A个性化装饰<br>";
    }
}

//具体装饰类B
class ConcreteDecoratorB extends Decorator
{
    public function __construct(Component $component)
    {
        parent::__construct($component);

    }

    public function operation()
    {
        parent::operation();
        $this->addedOperationB();   //  新增加的操作
    }

    public function addedOperationB()
    {
        echo "，又加了B个性化装饰<br><br>";
    }
}

//测试
$decoratorA = new ConcreteDecoratorA(new ConcreteComponent());
$decoratorA->operation();
$decoratorB = new ConcreteDecoratorB($decoratorA);
$decoratorB->operation();
/*
加了被装饰者，又加了A个性化装饰

加了被装饰者，又加了A个性化装饰
，又加了B个性化装饰
*/

五、工厂模式-》简单工厂
1、定义：工厂模式(Factor Pattern)分为简单工厂、工厂方法、抽象工厂，简单说简单工厂就是负责生成其他对象的类或方法。
2、模式动机：
(a)工厂模式可以将对象的生产从直接new 一个对象，改成通过调用一个工厂方法生产。这样的封装，代码若需修改new的对象时，不需修改多处new语句，只需更改生产对象方法。
(b)若所需实例化的对象可选择来自不同的类，可省略if-else多层判断，给工厂方法传入对应的参数，利用多态性，实例化对应的类。
©问题：如果按照简单工厂模式的话，声明一个工厂类，由工厂类判断调用哪个，那么必然存在工厂类不断修改的操作，每增加一个功能都要去修改工厂类，违背了【开放封闭】原则。
3、图示：

在这里插入图片描述
4、代码实现：

<?php
/**
 * Created by PhpStorm.
 * User: lenovo
 * Date: 2019/2/21
 * Time: 15:42
 */
header("Content-type:text/html;Charset=utf-8");

// 简单工厂

interface Car
{
    function getCar();
}


class SportCar implements Car
{

    function getCar()
    {
        echo '我要开跑车';
    }
}

class JeepCar implements Car
{

    function getCar()
    {
        echo '我要开越野车';
    }
}

class NoCar implements Car
{

    function getCar()
    {
        echo '你当我是变形金刚啊';
    }
}


class CarFactory
{

    function makeCar($car)
    {

        switch ($car) {
            case 'JeepCar';
                return new JeepCar();
            case 'SportCar';
                return new SportCar();
            default;
                return new NoCar();

        }
    }
}

$car = new CarFactory();
$jeepCar = $car->makeCar('JeepCar');
$jeepCar->getCar();
echo PHP_EOL;
$sportCar = $car->makeCar('SportCar');
$sportCar->getCar();
echo PHP_EOL;
$zxc = $car->makeCar('自行车');
$zxc->getCar();
echo PHP_EOL;
echo '***********************************************************';

六、工厂模式-》工厂方法
1、介绍：工厂方法模式Factory Method，又称多态性工厂模式。在工厂方法模式中，核心的工厂类不再负责所有的产品的创建，而是将具体创建的工作交给子类去做。该核心类成为一个抽象工厂角色，仅负责给出具体工厂子类必须实现的接口，而不接触哪一个产品类应当被实例化这种细节。

2、定义：工厂方法模式是简单工厂模式的衍生，解决了许多简单工厂模式的问题。首先完全实现‘开－闭 原则’，实现了可扩展。其次更复杂的层次结构，可以应用于产品结果复杂的场合。
3、图示：
在这里插入图片描述
4、代码实现：

<?php
/**
 * Created by PhpStorm.
 * User: lenovo
 * Date: 2019/2/21
 * Time: 15:42
 */
header("Content-type:text/html;Charset=utf-8");

// 简单工厂

interface Car
{
    function getCar();
}


class SportCar implements Car
{

    function getCar()
    {
        echo '我要开跑车';
    }
}

class JeepCar implements Car
{

    function getCar()
    {
        echo '我要开越野车';
    }
}

class NoCar implements Car
{

    function getCar()
    {
        echo '你当我是变形金刚啊';
    }
}


class CarFactory
{

    function makeCar($car)
    {

        switch ($car) {
            case 'JeepCar';
                return new JeepCar();
            case 'SportCar';
                return new SportCar();
            default;
                return new NoCar();

        }
    }
}

$car = new CarFactory();
$jeepCar = $car->makeCar('JeepCar');
$jeepCar->getCar();
echo PHP_EOL;
$sportCar = $car->makeCar('SportCar');
$sportCar->getCar();
echo PHP_EOL;
$zxc = $car->makeCar('自行车');
$zxc->getCar();
echo PHP_EOL;
echo '***********************简单工厂结束************************************';

echo PHP_EOL;
echo '***********************工厂方法开始************************************';
echo PHP_EOL;
/*
*工厂方法模式：
*定义一个创建对象的接口，让子类决定哪个类实例化。 他可以解决简单工厂模式中的封闭开放原则问题。
*/


interface createCar
{ // 注意了，这里是简单工厂本质区别所在，将对象的创建抽象成一个接口。
    function create();

}

class FactoryJeepCar implements createCar
{
    function create()
    {
        return new JeepCar();
    }
}

class FactorySportCar implements createCar
{
    function create()
    {
        return new SportCar();
    }
}

// 客户端 实现如下：
class Client
{
// 简单工厂里的静态方法
    function test()
    {
        $Factory = new FactoryJeepCar();
        $man = $Factory->create();
        $man->getCar();
        echo PHP_EOL;
        $Factory = new FactorySportCar();
        $man = $Factory->create();
        $man->getCar();
    }
}

$f = new Client;
$f->test();

echo PHP_EOL;
echo '***********************工厂方法结束************************************';

七、工厂模式-》抽象工厂

1、定义：抽象工厂模式为一组相关或相互依赖的对象创建提供接口，而无需指定其具体实现类。抽象工厂的客户端不关心如何创建这些对象，只关心如何将它们组合到一起。
2、抽象工厂的优点/缺点：
优点：
（a）抽象工厂模式隔离了具体类的生产，使得客户并不需要知道什么被创建。
当一个产品族中的多个对象被设计成一起工作时，它能保证客户端始终只使用同一个产品族中的对象。
(b)增加新的具体工厂和产品族很方便，无须修改已有系统，符合“开闭原则”。
缺点：
(a)增加新的产品等级结构很复杂，需要修改抽象工厂和所有的具体工厂类。

3、代码实现：

<?php
/**
 * Created by PhpStorm.
 * User: lenovo
 * Date: 2019/2/21
 * Time: 15:42
 */
header("Content-type:text/html;Charset=utf-8");

// 简单工厂
echo '***********************简单工厂开始************************************';
echo PHP_EOL;

interface Car
{
    function getCar();
}


class SportCar implements Car
{

    function getCar()
    {
        echo '我要开跑车';
    }
}

class JeepCar implements Car
{

    function getCar()
    {
        echo '我要开越野车';
    }
}

class NoCar implements Car
{

    function getCar()
    {
        echo '你当我是变形金刚啊';
    }
}


class CarFactory
{

    function makeCar($car)
    {

        switch ($car) {
            case 'JeepCar';
                return new JeepCar();
            case 'SportCar';
                return new SportCar();
            default;
                return new NoCar();

        }
    }
}

$car = new CarFactory();
$jeepCar = $car->makeCar('JeepCar');
$jeepCar->getCar();
echo PHP_EOL;
$sportCar = $car->makeCar('SportCar');
$sportCar->getCar();
echo PHP_EOL;
$zxc = $car->makeCar('自行车');
$zxc->getCar();
echo PHP_EOL;
echo '***********************简单工厂结束************************************';

echo PHP_EOL;
echo '***********************工厂方法开始************************************';
echo PHP_EOL;

/*
*工厂方法模式：
*定义一个创建对象的接口，让子类决定哪个类实例化。 他可以解决简单工厂模式中的封闭开放原则问题。
*/


interface createCar
{ // 注意了，这里是简单工厂本质区别所在，将对象的创建抽象成一个接口。
    function create();

}

class FactoryJeepCar implements createCar
{
    function create()
    {
        return new JeepCar();
    }
}

class FactorySportCar implements createCar
{
    function create()
    {
        return new SportCar();
    }
}

// 客户端 实现如下：
class Client
{
// 简单工厂里的静态方法
    function test()
    {
        $Factory = new FactoryJeepCar();
        $man = $Factory->create();
        $man->getCar();
        echo PHP_EOL;
        $Factory = new FactorySportCar();
        $man = $Factory->create();
        $man->getCar();
    }
}

$f = new Client;
$f->test();

echo PHP_EOL;
echo '***********************工厂方法结束************************************';
echo PHP_EOL;

echo '***********************抽象工厂开始************************************';
echo PHP_EOL;

/*
抽象工厂：提供一个创建一系列相关或相互依赖对象的接口。
注意：这里和工厂方法的区别是：一系列，而工厂方法则是一个。
*/

class JeepCarGreenAbstract implements Car
{
    function getCar()
    {
        echo '我要绿色越野<br>';
    }
}

class JeepCarBlueAbstract implements Car
{
    function getCar()
    {
        echo '我要蓝色越野<br>';
    }
}


class SportCarGreenAbstract implements Car
{
    function getCar()
    {
        echo '我要绿色超跑<br>';
    }
}

class SportCarBlueAbstract implements Car
{
    function getCar()
    {
        echo '我要蓝色超跑<br>';
    }
}


interface createCarAbstract
{ // 注意了，这里是本质区别所在，将对象的创建抽象成一个接口。
    function createBlueCar();

    function createGreenCar();
}

class FactoryJeepCarAbstract implements createCarAbstract
{
    function createBlueCar()
    {
        return new JeepCarBlueAbstract();
    }

    function createGreenCar()
    {
        return new JeepCarGreenAbstract();
    }
}

class FactorySportCarAbstract implements createCarAbstract
{
    function createBlueCar()
    {
        return new SportCarBlueAbstract();
    }

    function createGreenCar()
    {
        return new SportCarGreenAbstract();
    }
}


class ClientAbstractFactory
{
// 简单工厂里的静态方法
    function test()
    {
        $Factory = new FactorySportCarAbstract();
        $sportCar = $Factory->createBlueCar();
        echo PHP_EOL;
        $sportCar->getCar();
        echo PHP_EOL;
        $sportCar = $Factory->createGreenCar();
        $sportCar->getCar();
        echo PHP_EOL;

        $Factory = new FactoryJeepCarAbstract();
        $jeepCar = $Factory->createBlueCar();
        $jeepCar->getCar();
        echo PHP_EOL;
        $jeepCar = $Factory->createGreenCar();
        $jeepCar->getCar();
        echo PHP_EOL;
    }
}

$f = new ClientAbstractFactory;
$f->test();

echo '***********************抽象工厂结束************************************';
echo PHP_EOL;

八、工厂模式 总结
1、区别：
（a）简单工厂模式:用来生产同一等级结构中的任意产品。对与增加新的产品，无能为力
(b)工厂模式 ：用来生产同一等级结构中的固定产品。（支持增加任意产品）
©抽象工厂 ：用来生产不同产品族的全部产品。（对于增加新的产品，无能为力；支持增加产品族）
以上三种工厂 方法在等级结构和产品族这两个方向上的支持程度不同。所以要根据情况考虑应该使用哪种方法。

2、适用范围：

(a)简单工厂模式：工厂类负责创建的对象较少，客户只知道传入工厂类的参数，对于如何创建对象不关心。
(b)工厂方法模式：当一个类不知道它所必须创建对象的类或一个类希望由子类来指定它所创建的对象时，当类将创建对象的职责委托给多个帮助子类中得某一个，并且你希望将哪一个帮助子类是代理者这一信息局部化的时候，可以使用工厂方法模式。
©抽象工厂模式：一个系统不应当依赖于产品类实例何如被创建，组合和表达的细节，这对于所有形态的工厂模式都是重要的。这个系统有多于一个的产品族，而系统只消费其 中某一产品族。同属于同一个产品族的产品是在一起使用的，这一约束必须在系统的设计中体现出来。系统提供一个产品类的库，所有的产品以同样的接口出现，从 而使客户端不依赖于实现。
4、无论是简单工厂模式、工厂模式还是抽象工厂模式，它们本质上都是将不变的部分提取出来，将可变的部分留作接口，以达到最大程度上的复用。究竟用哪种设计模式更适合，这要根据具体的业务需求来决定。

九、其他模式（未完待续）

qq_21429395
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
php 设计模式
myzht1122的博客
02-28 178
设计模式 一书将设计模式引入软件社区，该书的作者是 Erich Gamma、Richard Helm、Ralph Johnson 和 John Vlissides Design（俗称 “四人帮”）。所介绍的设计模式背后的核心概念非常简单。经过多年的软件开发实践，Gamma 等人发现了某些具有固定设计的模式，就像建筑师设计房子和建筑物一样，可以为浴室的位置或厨房的构造方式开发模板。使用这些模板或者说...
PHP设计模式（一）OOP
weixin_44861853的博客
01-11 407
PHP设计模式（一）OOP面向对象编程 (OOP)OOP 的基本概念OOP 的核心思想OOP 的基本特征封装继承多态 面向对象编程 (OOP) 在学习设计模式之前，需要了解什么是面向对象编程 (OOP) 。 OOP 的基本概念 面向对象编程是一种程序设计思想。面向对象编程是将对象作为程序的基本单元，对象在 PHP 中就是类，对象由两大部分组成，分别称为属性和方法。其中，属性是指变量和常量，方法是指函数。 OOP 的核心思想 面向对象编程 (OOP) 的核心设计思想是抽象。 抽象指示一个对象的基本特征，使它与
PHP 设计模式之最全面,最简单的讲解
kafeibujianai的博客
07-22 3998
PHP 最全面的设计模式
PHP实现各种设计模式
wyqgg123的博客
06-27 182
1 单例模式 一个类只允许创建一个对象 应用场景：多次请求数据库只需要一个连接对象。 优点： 1、在内存里只有一个实例，减少了内存的开销，尤其是频繁的创建和销毁实例（比如管理学院首页页面缓存）。 2、避免对资源的多重占用（比如写文件操作）。 缺点： 没有接口，不能继承，与单一职责原则冲突，一个类应该只关心内部逻辑，而不关心外面怎么样来实例化。 1、私有的静态属性来保存对象的实例 2、私有的构造函数阻止类的外部实例化对象 3、私有的__clone()函数阻止类的外部克隆对象 4、公有的静态函数保证外部获取对象
php 24种设计模式_16个PHP设计模式详解
weixin_40000430的博客
03-09 262
说明：该教程全部截选自实验楼教程【16个PHP设计模式详解】：主要介绍16个常用的设计模式的基础概念和技术要点，通过UML类图帮助理解设计模式中各个类之间的关联关系，针对每种设计模式都使用PHP完成了一个代码示例，让你跟随实例轻松入门设计模式。一、工厂模式工厂模式具体可分为三类模式：简单工厂模式，工厂方法模式，抽象工厂模式；1.简单工厂模式又称为静态工厂方法(Static Factory Meth...
php的设计模式如何实现,常见的PHP设计模式和实现
weixin_28753113的博客
03-18 179
全部设计模式请看《PHP设计模式教程》不论是 PHP、Java还是C++编程语言，在编程的时候，我们所遇到的大部分问题，其实都已经被其他程序员一再的处理了。设计模式提取了共同问题，定义了经过测试的解决方案，并描述了可能的结果。也就是说，设计模式(Patterns)是一些可以在项目中重复使用的解决方案。但是，设计模式并非像组件那样，能被合并来构建系统的固定的解决方案，它们是解决一般性问题的通用方法。...
PHP设计模式的实现
weixin_42715180的博客
11-01 156
单例模式 单例模式，是一种常见的软件设计模式。在它的核心结构中包含一个被称为特殊的单例。通过单例模式可以保证系统中一个类只有一个实例，即一个类只有一个对象实例。 实现单例模式 拥有一个构造函数并且为 private ，也就是不能new，不能clone 一个静态变量，保存类中的唯一实例 一个公共可访问的静态方法 <?php /** * 单例模式 */ Class singleton {...
用PHP语言实现16个设计模式.zip
01-09
本资源“用PHP语言实现16个设计模式.zip”提供了关于如何在PHP环境中应用这些模式的详细指导。以下是这16个设计模式的概述，以及它们在实际开发中的应用和重要性。 1. 单例模式：确保一个类只有一个实例，并提供...
php 23种设计模式-整理篇.zip
07-29
PHP作为一门广泛应用于Web开发的语言，同样可以应用23种经典的GOF（GoF，Gang of Four）设计模式。这些模式提供了可重用的结构，提高了代码的可读性和可维护性。下面将对这23种设计模式进行详细阐述： 1. **单例...
php设计模式大全php设计模式大全
11-21
《PHP设计模式大全》 设计模式是软件工程中的一种最佳实践，它是在特定上下文中解决常见问题的经验总结。在PHP编程中，理解并熟练运用设计模式对于提升代码质量、可维护性和可扩展性至关重要。本篇文章将深入探讨...
php设计模式代码
06-29
常用php设计模式代码以及注释，此代码是本人写的，有什么问题可以问我。
PHP设计模式1
08-04
书中的内容专注于对Web应用程序开发有帮助的设计模式，并通过PHP语言进行了示例实现，尤其是基于面向对象编程（OOP）的原则。 OOP是设计模式的基础，它提倡将复杂问题分解为可管理的小模块，以提高代码的可测试性、...
学习php设计模式 php实现状态模式
10-23
主要介绍了php设计模式中的状态模式，使用php实现状态模式，感兴趣的小伙伴们可以参考一下
设计模式--PHP实现
jaymegs的博客
02-25 236
一、生成对象： 1、单例模式 确保某一个类只有一个实例，并且提供一个全局访问点。 单例模式具备如下几个特点： 1、只有一个实例。 2、能够自我实例化。 3、提供全局访问点。 　所以说当系统中只需要一个实例对象或者系统中只允许一个公共访问点，除了这个公共访问点外，不能通过其他访问点访问该实例时，可以使用单例模式。 　单例模式的主...
PHP八大设计模式
热门推荐
flitrue的博客
09-21 4万+
PHP命名空间可以更好地组织代码，与Java中的包类似。 Test1.php <?php namespace Test1;//命名空间Test1 function test(){ echo __FILE__; } Test2.php <?php namespace Test2; //命名空间Test2 function test(){ echo __FILE__;//打印当前文件所
php的几种设计模式（代码实现及说明）
派煌篇的博客
01-10 722
/** * Class single * 单利模式 * 单例模式可以有效避免不同程序员new自己的对象，造成人为的系统消耗 */ final class single { private static $obj; private function __construct(){ } private function __clone(){ } ...
PHP版23种设计模式简单的实现
u014068781的专栏
03-07 397
PHP版23种设计模式简单的实现和说明。github：https://github.com/ZhangZhenBin/DesignPattern-PHPPHP版23种设计模式简单的实现总结面向对象实际上就两句话:一是松耦合(Coupling),二是高内聚(Cohesion)。 面向对象系统追求的目标就是尽可能地提高系统模块内部的内聚(Cohesion)、尽可能降低模 块间的耦合(Coupling)...
《C++20设计模式》命令模式思考
最新发布
Ten_years_star的博客
07-07 458
哎！只要是书上写的和经典设计模式不同，我就会很伤脑筋。😩 **命令模式到底是干什么的？** 答：命令的发送者和接收者完全解耦
DPT-一种PHP设计模式.docx
05-11
"DPT是一种PHP设计模式，旨在改善PHP在处理大型应用时的不足，如不完整的面向对象机制和数据库处理的局限性。该模式受到Java的MVC模式启发，但更接近于Java的DAO模式，但DPT将业务逻辑与数据访问层结合在一起。DPT...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值