精华内容
下载资源
问答
  • Java常见的五种设计模式

    千次阅读 2019-09-10 13:45:43
    Java常见的五种设计模式1 工厂模式2 静态工厂模式3 单例模式4 建造者模式5 原型模式 1 工厂模式 常用的为静态工厂模式,类似于工具类,只负责输入输出的功能,静态的好处是不用去实例化这个工厂,可以直接调用里面的...

    1 工厂模式

    常用的为静态工厂模式,类似于工具类,只负责输入输出的功能,静态的好处是不用去实例化这个工厂,可以直接调用里面的方法。

    2 静态工厂模式

    典型的是service层的模式,通过接口和实现类来实现产品的功能。这样的好处是不用修改原来的代码,只需要新增接口和新增实现方法就可以了。

    3 单例模式

    在内部创建一个实例,所有方法都在这个实例上改动,因为这个实例化只有一次,所以每次都指向同一个实例,避免了反复的创建对象和内存的浪费,缺点是拓展性差,在对象多元化的场景不适用。

    4 建造者模式

    通过链式调用来创建和赋值对象,注解@Accessors就是如此,方便快捷。

    5 原型模式

    通过实现CloneAble来克隆对象,这种创建对象不必实现构造方法等,因为是直接复制字节流实现的,但是实际应用作用不大。

    展开全文
  • 概述: 常见的设计模式有61.单例设计模式2.简单工厂模式3.观察者模式4.适配器模式5.策略模式6.装饰器模式下面分别讲各种模式的使用和场景一.单例设计模式1.$_instance必须声明为静态的私有变量2.构造函数必须声明...

    概述: 常见的设计模式有6种

    1.单例设计模式

    2.简单工厂模式

    3.观察者模式

    4.适配器模式

    5.策略模式

    6.装饰器模式

    下面分别讲各种模式的使用和场景

    一.单例设计模式

    1.$_instance      必须声明为静态的私有变量

    2.构造函数必须声明为私有,防止外部程序new类从而失去单例模式的意义

    3.getInstance()方法必须设置为公有的,必须调用此方法以返回实例的一个引用

    4.::操作符只能访问静态变量和静态函数

    5.new对象都会消耗内存

    6.使用场景:最常用的地方是数据库连接。

    7.使用单例模式生成一个对象后,该对象可以被被其它众多对象所使用。

    class Db {

    //保存例实例在此属性中

    private static $_instance;

    //构造函数声明为private,防止直接创建对象

    private function __construct() { echo '我被实例化了!'; }

    //单例方法

    public static function get_instance() {

    if(!isset(self::$_instance)) {

    self::$_instance=new self();

    }

    return self::$_instance;

    }

    //阻止用户复制对象实例

    private function __clone() { trigger_error('Clone is not allow' ,E_USER_ERROR); }

    }

    //这个写法会出错,因为构造方法被声明为private

    //$test = new Db();

    //下面将得到Example类的单例对象

    $Db = Db::get_instance();

    二.简单工厂模式

    /抽象基类:类中定义抽象一些方法,用以在子类中实现 *继承自抽象基类的子类:实现基类中的抽象方法 *工厂类:用以实例化所有相对应的子类 **/

    /** * * 定义个抽象的类,让子类去继承实现它 * */

    abstractclassOperation{//抽象方法不能包含函数体abstractpublicfunctiongetValue($num1,$num2);//强烈要求子类必须实现该功能函数}/**

    * 加法类

    */classOperationAddextendsOperation{publicfunctiongetValue($num1,$num2){return$num1+$num2;    } }/**

    * 减法类

    */classOperationSubextendsOperation{publicfunctiongetValue($num1,$num2){return$num1-$num2;    } }/**

    * 乘法类

    */classOperationMulextendsOperation{publicfunctiongetValue($num1,$num2){return$num1*$num2;    } }/**

    * 除法类

    */classOperationDivextendsOperation{publicfunctiongetValue($num1,$num2){try{if($num2==0){thrownewException("除数不能为0");            }else{return$num1/$num2;            }        }catch(Exception$e){echo"错误信息:".$e->getMessage();        }    } }/**

    * 工程类,主要用来创建对象

    * 功能:根据输入的运算符号,工厂就能实例化出合适的对象

    *

    */classFactory{publicstaticfunctioncreateObj($operate){switch($operate){case'+':returnnewOperationAdd();break;case'-':returnnewOperationSub();break;case'*':returnnewOperationSub();break;case'/':returnnewOperationDiv();break;        }    }}$obj=Factory::createObj('/');$result=$obj->getValue(23,0);//工厂模式理解:以交通工具为例子:要求请既可以定制交通工具,又可以定制交通工具生产的过程

    1>定制交通工具 1.定义一个接口,里面包含交工工具的方法(启动 运行 停止) 2.让飞机,汽车等类去实现他们 2> 定制工厂(通上类似) 1.定义一个接口,里面包含交工工具的制造方法(启动 运行 停止) 2.分别写制造飞机,汽车的工厂类去继承实现这个接口

    三.观察者模式/**

    *观察者模式属于行为模式,是定义对象间的一种一对多的依赖关系,以便当一个对象的    *状态发生改变时,所有依赖于它的对象都得到通知并自动刷新。它完美的将观察者对象    *和被观察者对象分离。可以在独立的对象(主体)中维护一个对主体感兴趣的依赖项(    *观察器)列表。 让所有观察器各自实现公共的Observer接口,以取消主体和依赖性对象    *之间的直接依赖关系

    **/classMyObserver1implementsSplObserver{publicfunctionupdate(SplSubject $subject){echo__CLASS__.' - '. $subject->getName();}

    }

    class MyObserver2 implements SplObserver { public function update(SplSubject $subject) { echo CLASS . ' - ' . $subject->getName(); } }

    class MySubject implements SplSubject { private $_observers; private $_name;

    publicfunction__construct($name){$this->_observers =newSplObjectStorage();$this->_name = $name;}publicfunctionattach(SplObserver $observer){$this->_observers->attach($observer);}publicfunctiondetach(SplObserver $observer){$this->_observers->detach($observer);}publicfunctionnotify(){foreach($this->_observersas$observer) {        $observer->update($this);    }}publicfunctiongetName(){return$this->_name;}

    }

    $observer1 = new MyObserver1(); $observer2 = new MyObserver2();

    $subject = new MySubject("test");

    $subject->attach($observer1); $subject->attach($observer2);

    四.策略模式 /**

    在此模式中,算法是从复杂类提取的,因而可以方便地替换。例如,如果要更改搜索引擎列页的方法,则策略模式是一个不错的选择。思考一下搜索引擎的几个部分——一部分遍历页面*,一部分对每页排列,另一部分基于排列的结果排序。在复杂的示例中,这些部分都在同一个类中。通过使用策略模式,您可将排列部分放入另一个类中,以便更改页排列的方式,而不影响搜索引擎的其余代码 **/

    //定义接口 interface IStrategy { function filter($record); }

    //实现接口方式1 class FindAfterStrategy implements IStrategy { private $_name; public function __construct($name) { $this->_name = $name; } public function filter($record) { return strcmp ( $this->_name, $record ) <= 0; } }

    //实现接口方式1 class RandomStrategy implements IStrategy { public function filter($record) { return rand ( 0, 1 ) >= 0.5; } }

    //主类 class UserList { private $_list = array (); public function __construct($names) { if ($names != null) { foreach ( $names as $name ) { $this->_list [] = $name; } } }

    publicfunctionadd($name){$this->_list [] = $name;}publicfunctionfind($filter){    $recs =array();foreach($this->_listas$user ) {if($filter->filter ( $user ))            $recs [] = $user;    }return$recs;}

    }

    $ul = new UserList ( array ( "Andy", "Jack", "Lori", "Megan" ) ); $f1 = $ul->find ( new FindAfterStrategy ( "J" ) ); print_r ( $f1 );

    $f2 = $ul->find ( new RandomStrategy () );

    策略模式非常适合复杂数据管理系统或数据处理系统,二者在数据筛选、搜索或处理的方式方面需要较高的灵活

    展开全文
  • PHP中常见的五种设计模式 :http://www.php-note.com/article/detail/147 一、工厂模式 最初在设计模式 一书中,许多设计模式都鼓励使用松散耦合。要理解这个概念,让我们最好谈一下许多开发人员从事大型系统的...

    PHP中常见的五种设计模式 :http://www.php-note.com/article/detail/147

    一、工厂模式

     

    最初在设计模式 一书中,许多设计模式都鼓励使用松散耦合。要理解这个概念,让我们最好谈一下许多开发人员从事大型系统的艰苦历程。在更改一个代码片段时,就会发生问题,系统其他部分 —— 您曾认为完全不相关的部分中也有可能出现级联破坏。

     

    该问题在于紧密耦合 。系统某个部分中的函数和类严重依赖于系统的其他部分中函数和类的行为和结构。您需要一组模式,使这些类能够相互通信,但不希望将它们紧密绑定在一起,以避免出现联锁。

     

    在大型系统中,许多代码依赖于少数几个关键类。需要更改这些类时,可能会出现困难。例如,假设您有一个从文件读取的 User 类。您希望将其更改为从数据库读取的其他类,但是,所有的代码都引用从文件读取的原始类。这时候,使用工厂模式会很方便。

     

    工厂模式 是一种类,它具有为您创建对象的某些方法。您可以使用工厂类创建对象,而不直接使用 new。这样,如果您想要更改所创建的对象类型,只需更改该工厂即可。使用该工厂的所有代码会自动更改。

     

    清单 1 显示工厂类的一个示列。等式的服务器端包括两个部分:数据库和一组 PHP 页面,这些页面允许您添加反馈、请求反馈列表并获取与特定反馈相关的文章。

     

    清单 1. Factory1.php

    <?php
    interface IUser
    {
    	function getName();
    }
    
    class User implements IUser
    {
    	public function __construct($id) {
    
    	}
    
    	public function getName() {
    		return "Jack";
    	}
    }
    
    class UserFactory
    {
    	public static function Create($id) {
    		return new User($id);
    	}
    }
    
    $uo = UserFactory::Create(1);
    echo($uo->getName() . "
    ");
    ?>
    

     IUser 接口定义用户对象应执行什么操作。IUser 的实现称为 User,UserFactory 工厂类则创建 IUser 对象。

    % php factory1.php
    Jack
    %
    

    测试代码会向工厂请求 User 对象,并输出 getName 方法的结果。

    有一种工厂模式的变体使用工厂方法。类中的这些公共静态方法构造该类型的对象。如果创建此类型的对象非常重要,此方法非常有用。例如,假设您需要先创建对象,然后设置许多属性。此版本的工厂模式会将该进程封装在单个位置中,这样,不用复制复杂的初始化代码,也不必将复制好的代码在在代码库中到处粘贴。

    清单 2 显示使用工厂方法的一个示例。

    清单 2. Factory2.php

    <?php
    interface IUser
    {
    	function getName();
    }
    
    class User implements IUser
    {
    	public static function Load($id) {
    		return new User($id);
    	}
    
    	public static function Create() {
    		return new User(null);
    	}
    
    	public function __construct($id) {
    
    	}
    
    	public function getName() {
    		return "Jack";
    	}
    }
    
    $uo = User::Load(1);
    echo($uo->getName() . "
    ");
    ?>
    

     这段代码要简单得多。它仅有一个接口 IUser 和一个实现此接口的 User 类。User 类有两个创建对象的静态方法。

    二、单元素模式

    某些应用程序资源是独占的,因为有且只有一个此类型的资源。例如,通过数据库句柄到数据库的连接是独占的。您希望在应用程序中共享数据库句柄,因为在保持连接打开或关闭时,它是一种开销,在获取单个页面的过程中更是如此。

    单元素模式可以满足此要求。如果应用程序每次包含且仅包含一个对象,那么这个对象就是一个单元素(Singleton)。清单 3 中的代码显示了 PHP V5 中的一个数据库连接单元素。

    清单 3. Singleton.php

    <?php
    require_once("DB.php");
    
    class DatabaseConnection
    {
    public static function get()
    {
    static $db = null;
    if ( $db == null )
    $db = new DatabaseConnection();
    return $db;
    }
    
    private $_handle = null;
    
    private function __construct()
    {
    $dsn = 'mysql://root:password@localhost/photos';
    $this->_handle =& DB::Connect( $dsn, array() );
    }
    
    public function handle()
    {
    return $this->_handle;
    }
    }
    
    print( "Handle = ".DatabaseConnection::get()->handle()."\n" );
    print( "Handle = ".DatabaseConnection::get()->handle()."\n" );
    ?>
    

    此代码显示名为 DatabaseConnection 的单个类。您不能创建自已的 DatabaseConnection,因为构造函数是专用的。但使用静态 get方法,您可以获得且仅获得一个 DatabaseConnection 对象。

    在两次调用间,handle 方法返回的数据库句柄是相同的,这就是最好的证明。您可以在命令行中运行代码来观察这一点。

    % php singleton.php
    Handle = Object id #3
    Handle = Object id #3
    %
    

    返回的两个句柄是同一对象。如果您在整个应用程序中使用数据库连接单元素,那么就可以在任何地方重用同一句柄。

    您可以使用全局变量存储数据库句柄,但是,该方法仅适用于较小的应用程序。在较大的应用程序中,应避免使用全局变量,并使用对象和方法访问资源。

     三、观察者模式

    观察者模式为您提供了避免组件之间紧密耦合的另一种方法。该模式非常简单:一个对象通过添加一个方法(该方法允许另一个对象,即观察者 注册自己)使本身变得可观察。当可观察的对象更改时,它会将消息发送到已注册的观察者。这些观察者使用该信息执行的操作与可观察的对象无关。结果是对象可以相互对话,而不必了解原因。

    一个简单示例是系统中的用户列表。清单 4 中的代码显示一个用户列表,添加用户时,它将发送出一条消息。添加用户时,通过发送消息的日志观察者可以观察此列表。

    清单 4. Observer.php

    <?php
    interface IObserver
    {
    	function onChanged($sender, $args);
    }
    
    interface IObservable
    {
    	function addObserver($observer);
    }
    
    class UserList implements IObservable
    {
    	private $_observers = array();
    
    	public function addCustomer($name) {
    		foreach($this->_observers as $obs) {
    			$obs->onChanged($this, $name);
    		}
    	}
    
    	public function addObserver($observer ) {
    		$this->_observers[] = $observer;
    	}
    }
    
    class UserListLogger implements IObserver
    {
    	public function onChanged($sender, $args) {
    		echo("'$args' added to user list
    ");
    	}
    }
    
    $ul = new UserList();
    $ul->addObserver(new UserListLogger());
    $ul->addCustomer("Jack");
    ?>
    

     此代码定义四个元素:两个接口和两个类。IObservable 接口定义可以被观察的对象,UserList 实现该接口,以便将本身注册为可观察。IObserver 列表定义要通过怎样的方法才能成为观察者,UserListLogger 实现 IObserver 接口。

    % php observer.php
    'Jack' added to user list
    %
    

    测试代码创建 UserList,并将 UserListLogger 观察者添加到其中。然后添加一个消费者,并将这一更改通知 UserListLogger

    认识到 UserList 不知道日志程序将执行什么操作很关键。可能存在一个或多个执行其他操作的侦听程序。例如,您可能有一个向新用户发送消息的观察者,欢迎新用户使用该系统。这种方法的价值在于 UserList 忽略所有依赖它的对象,它主要关注在列表更改时维护用户列表并发送消息这一工作。

    此模式不限于内存中的对象。它是在较大的应用程序中使用的数据库驱动的消息查询系统的基础。

    四、命令链模式

    命令链 模式以松散耦合主题为基础,发送消息、命令和请求,或通过一组处理程序发送任意内容。每个处理程序都会自行判断自己能否处理请求。如果可以,该请求被处理,进程停止。您可以为系统添加或移除处理程序,而不影响其他处理程序。清单 5 显示了此模式的一个示例。

    清单 5. Chain.php

    <?php
    interface ICommand
    {
    	function onCommand($name, $args);
    }
    
    class CommandChain
    {
    	private $_commands = array();
    
    	public function addCommand($cmd) {
    		$this->_commands[] = $cmd;
    	}
    
    	public function runCommand($name, $args) {
    		foreach ($this->_commands as $cmd ) {
    			if ($cmd->onCommand($name, $args)) {
    				return;
    			}
    		}
    	}
    }
    
    class UserCommand implements ICommand
    {
    	public function onCommand($name, $args) {
    		if ($name != 'addUser' ) {
    			return false;
    		}
    		echo("UserCommand handling 'addUser'
    ");
    		return true;
    	}
    }
    
    class MailCommand implements ICommand
    {
    	public function onCommand($name, $args) {
    		if ($name != 'mail') {
    			return false;
    		}
    		echo("MailCommand handling 'mail'
    ");
    		return true;
    	}
    }
    
    $cc = new CommandChain();
    $cc->addCommand(new UserCommand());
    $cc->addCommand(new MailCommand());
    $cc->runCommand('addUser', null);
    $cc->runCommand('mail', null);
    ?>
    

     此代码定义维护 ICommand 对象列表的 CommandChain 类。两个类都可以实现 ICommand 接口 —— 一个对邮件的请求作出响应,另一个对添加用户作出响应。

    如果您运行包含某些测试代码的脚本,则会得到以下输出:

    % php chain.php
    UserCommand handling 'addUser'
    MailCommand handling 'mail'
    %
    

    代码首先创建 CommandChain 对象,并为它添加两个命令对象的实例。然后运行两个命令以查看谁对这些命令作出了响应。如果命令的名称匹配 UserCommand 或 MailCommand,则代码失败,不发生任何操作。

    为处理请求而创建可扩展的架构时,命令链模式很有价值,使用它可以解决许多问题。

    五、策略模式

    我们讲述的最后一个设计模式是策略 模式。在此模式中,算法是从复杂类提 取的,因而可以方便地替换。例如,如果要更改搜索引擎中排列页的方法,则策略模式是一个不错的选择。思考一下搜索引擎的几个部分 —— 一部分遍历页面,一部分对每页排列,另一部分基于排列的结果排序。在复杂的示例中,这些部分都在同一个类中。通过使用策略模式,您可将排列部分放入另一个 类中,以便更改页排列的方式,而不影响搜索引擎的其余代码。

    作为一个较简单的示例,清单 6 显示了一个用户列表类,它提供了一个根据一组即插即用的策略查找一组用户的方法。

    清单 6. Strategy.php

    <?php
    interface IStrategy
    {
    	function filter($record);
    }
    
    class FindAfterStrategy implements IStrategy
    {
    	private $_name;
    
    	public function __construct($name) {
    		$this->_name = $name;
    	}
    
    	public function filter($record) {
    		return strcmp($this->_name, $record) <= 0;
    	}
    }
    
    class RandomStrategy implements IStrategy
    {
    	public function filter($record) {
    		return rand(0, 1) >= 0.5;
    	}
    }
    
    class UserList
    {
    	private $_list = array();
    
    	public function __construct($names) {
    		if ($names != null) {
    			foreach($names as $name) {
    			$this->_list[]= $name;
    		}
    		}
    	}
    
    	public function add($name) {
    		$this->_list[] = $name;
    	}
    
    	public function find($filter) {
    		$recs = array();
    		foreach ($this->_list as $user) {
    			if ($filter->filter($user)) {
    				$recs []= $user;
    			}
    		}
    
    		return $recs;
    	}
    }
    
    $ul = new UserList(array("Andy", "Jack", "Lori", "Megan"));
    $f1 = $ul->find(new FindAfterStrategy("J"));
    print_r($f1);
    
    $f2 = $ul->find(new RandomStrategy());
    print_r($f2);
    ?>
    

     UserList 类是打包名称数组的一个包装器。它实现 find 方法,该方法利用几个策略之一来选择这些名称的子集。这些策略由IStrategy 接口定义,该接口有两个实现:一个随机选择用户,另一个根据指定名称选择其后的所有名称。运行测试代码时,将得到以下输出:

    % php strategy.php
    Array
    (
        [0] => Jack
        [1] => Lori
        [2] => Megan
    )
    Array
    (
        [0] => Andy
        [1] => Megan
    )
    %
    

    测试代码为两个策略运行同一用户列表,并显示结果。在第一种情况中,策略查找排列在 J 后的任何名称,所以您将得到 Jack、Lori 和 Megan。第二个策略随机选取名称,每次会产生不同的结果。在这种情况下,结果为 Andy 和 Megan。

    策略模式非常适合复杂数据管理系统或数据处理系统,二者在数据筛选、搜索或处理的方式方面需要较高的灵活性。

    结束语

    本文介绍的仅仅是 PHP 应用程序中使用的几种最常见的设计模式。在设计模式 一书中演示了更多的设计模式。不要因架构的神秘性而放弃。模式是一种绝妙的理念,适用于任何编程语言、任何技能水平。

     

    转载于:https://www.cnblogs.com/zhuiluoyu/p/5153570.html

    展开全文
  • 策略模式功能非常强大,因为这个设计模式本身核心思想就是面向对象编程多形性思想。 策略模式三个角色: 1.抽象策略角色 2.具体策略角色 3.环境角色(对抽象策略角色引用) 实现步骤: 1.定义抽象...

    策略模式

    策略模式是对象的行为模式,用意是对一组算法的封装。动态的选择需要的算法并使用。

    策略模式指的是程序中涉及决策控制的一种模式。策略模式功能非常强大,因为这个设计模式本身的核心思想就是面向对象编程的多形性思想。

    策略模式的三个角色:

    1.抽象策略角色

    2.具体策略角色

    3.环境角色(对抽象策略角色的引用)

    实现步骤:

    1.定义抽象角色类(定义好各个实现的共同抽象方法)

    2.定义具体策略类(具体实现父类的共同方法)

    3.定义环境角色类(私有化申明抽象角色变量,重载构造方法,执行抽象方法)

    就在编程领域之外,有许多例子是关于策略模式的。例如:

    如果我需要在早晨从家里出发去上班,我可以有几个策略考虑:我可以乘坐地铁,乘坐公交车,走路或其它的途径。每个策略可以得到相同的结果,但是使用了不同的资源。

    策略模式的代码实例:

    <?php
        abstract class baseAgent { //抽象策略类
            abstract function PrintPage();
        }
        //用于客户端是IE时调用的类(环境角色)
        class ieAgent extends baseAgent {
            function PrintPage() {
                return 'IE';
            }
        }
        //用于客户端不是IE时调用的类(环境角色)
        class otherAgent extends baseAgent {
            function PrintPage() {
                return 'not IE';
            }
        }
        class Browser { //具体策略角色
            public function call($object) {
                    return $object->PrintPage ();
                }
            }
            $bro = new Browser ();
        echo $bro->call ( new ieAgent () );
    ?>
    

    工厂模式

    工厂模式是我们最常用的实例化对象模式,是用工厂方法代替new操作的一种模式。

    使用工厂模式的好处是,如果你想要更改所实例化的类名等,则只需更改该工厂方法内容即可,不需逐一寻找代码中具体实例化的地方(new处)修改了。为系统结构提供灵活的动态扩展机制,减少了耦合。

    <?php
    header('Content-Type:text/html;charset=utf-8');
    /**
     *简单工厂模式(静态工厂方法模式)
     */
    /**
     * Interface people 人类
     */
    interface  people
    {
        public function  say();
    }
    /**
     * Class man 继承people的男人类
     */
    class man implements people
    {
        // 具体实现people的say方法
        public function say()
        {
            echo '我是男人<br>';
        }
    }
    /**
     * Class women 继承people的女人类
     */
    class women implements people
    {
        // 具体实现people的say方法
        public function say()
        {
            echo '我是女人<br>';
        }
    }
    /**
     * Class SimpleFactoty 工厂类
     */
    class SimpleFactoty
    {
        // 简单工厂里的静态方法-用于创建男人对象
        static function createMan()
        {
            return new man();
        }
        // 简单工厂里的静态方法-用于创建女人对象
        static function createWomen()
        {
            return new women();
        }
    }
    /**
     * 具体调用
     */
    $man = SimpleFactoty::createMan();
    $man->say();
    $woman = SimpleFactoty::createWomen();
    $woman->say();
    

    单例模式

    单例模式确保某个类只有一个实例,而且自行实例化并向整个系统提供这个实例。

    单例模式是一种常见的设计模式,在计算机系统中,线程池、缓存、日志对象、对话框、打印机、数据库操作、显卡的驱动程序常被设计成单例。

    单例模式分3种:懒汉式单例、饿汉式单例、登记式单例。

    单例模式有以下3个特点:

    1.只能有一个实例。

    2.必须自行创建这个实例。

    3.必须给其他对象提供这一实例。

    那么为什么要使用PHP单例模式?

    PHP一个主要应用场合就是应用程序与数据库打交道的场景,在一个应用中会存在大量的数据库操作,针对数据库句柄连接数据库的行为,使用单例模式可以避免大量的new操作。因为每一次new操作都会消耗系统和内存的资源。

    class Single {
        private $name;//声明一个私有的实例变量
        private function __construct(){//声明私有构造方法为了防止外部代码使用new来创建对象。
        }
        static public $instance;//声明一个静态变量(保存在类中唯一的一个实例)
            static public function getinstance(){//声明一个getinstance()静态方法,用于检测是否有实例对象
            if(!self::$instance) self::$instance = new self();
                return self::$instance;
        }
        public function setname($n){ $this->name = $n; }
            public function getname(){ return $this->name; }
    }
    $oa = Single::getinstance();
    $ob = Single::getinstance();
    $oa->setname('hello world');
    $ob->setname('good morning');
    echo $oa->getname();//good morning
    echo $ob->getname();//good morning
    

    注册模式

    注册模式,解决全局共享和交换对象。已经创建好的对象,挂在到某个全局可以使用的数组上,在需要使用的时候,直接从该数组上获取即可。将对象注册到全局的树上。任何地方直接去访问。

    <?php
    class Register
    {
        protected static  $objects;
            function set($alias,$object)//将对象注册到全局的树上
            {
                self::$objects[$alias]=$object;//将对象放到树上
            }
            static function get($name){
            return self::$objects[$name];//获取某个注册到树上的对象
        }
        function _unset($alias)
      {
            unset(self::$objects[$alias]);//移除某个注册到树上的对象。
        }
    }
    

    适配器模式

    将各种截然不同的函数接口封装成统一的API。

    PHP中的数据库操作有MySQL,MySQLi,PDO三种,可以用适配器模式统一成一致,使不同的数据库操作,统一成一样的API。类似的场景还有cache适配器,可以将memcache,redis,file,apc等不同的缓存函数,统一成一致。
    首先定义一个接口(有几个方法,以及相应的参数)。然后,有几种不同的情况,就写几个类实现该接口。将完成相似功能的函数,统一成一致的方法。

    接口 IDatabase
    <?php
    namespace IMooc;
    interface IDatabase
    {
        function connect($host, $user, $passwd, $dbname);
        function query($sql);
        function close();
    }
    

    MySQL

    <?php
    namespace IMooc\Database;
    use IMooc\IDatabase;
    class MySQL implements IDatabase
    {
        protected $conn;
            function connect($host, $user, $passwd, $dbname)
            {
                $conn = mysql_connect($host, $user, $passwd);
                mysql_select_db($dbname, $conn);
                $this->conn = $conn;
        }
        function query($sql)
            {
                $res = mysql_query($sql, $this->conn);
                return $res;
        }
        function close()
        {
            mysql_close($this->conn);
        }
    }
    

    MySQLi

    <?php
    namespace IMooc\Database;
    use IMooc\IDatabase;
    class MySQLi implements IDatabase
    {
        protected $conn;
        function connect($host, $user, $passwd, $dbname)
        {
            $conn = mysqli_connect($host, $user, $passwd, $dbname);
            $this->conn = $conn;
        }
        function query($sql)
        {
            return mysqli_query($this->conn, $sql);
        }
        function close()
        {
            mysqli_close($this->conn);
        }
    }
    

    观察者模式

    1:观察者模式(Observer),当一个对象状态发生变化时,依赖它的对象全部会收到通知,并自动更新。
    2:场景:一个事件发生后,要执行一连串更新操作。传统的编程方式,就是在事件的代码之后直接加入处理的逻辑。当更新的逻辑增多之后,代码会变得难以维护。这种方式是耦合的,侵入式的,增加新的逻辑需要修改事件的主体代码。
    3:观察者模式实现了低耦合,非侵入式的通知与更新机制。 定义一个事件触发抽象类。

    EventGenerator.php
    <?php
    require_once 'Loader.php';
    abstract class EventGenerator{
        private $observers = array();
            function addObserver(Observer $observer){
            $this->observers[]=$observer;
        }
        function notify(){
            foreach ($this->observers as $observer){
                $observer->update();
            }
        }
    }
    

    定义一个观察者接口

    Observer.php
    
    <?php
    
    require_once 'Loader.php';
    interface Observer{
        function update();//这里就是在事件发生后要执行的逻辑
    }
    //一个实现了EventGenerator抽象类的类,用于具体定义某个发生的事件
    

    实现

    require 'Loader.php';
    class Event extends EventGenerator{
        function triger(){
            echo "Event<br>";
        }
    }
    class Observer1 implements Observer{
        function update(){
            echo "逻辑1<br>";
        }
    }
    class Observer2 implements Observer{
        function update(){
            echo "逻辑2<br>";
        }
    }
    $event = new Event();
    $event->addObserver(new Observer1());
    $event->addObserver(new Observer2());
    $event->triger();
    $event->notify();
    
    展开全文
  • 您可能感兴趣文章:设计模式只是为 Java架构师准备 — 至少您可能一直这样认为。实际上,设计模式对于每个人都非常有用。如果这些工具不是 “架构太空人” 专利,那么它们又是什么?为什么说它们在 PHP 应用...
  • 1 策略模式 <?php interface IStrategy { function filter($rec); } class Finder implements IStrategy { private $name; public function __construct($name) { ...
  • 设计模式不仅代表着更快开发健壮软件有用方法,而且还提供了以友好术语封装大型理念方法。例如,您可以说您正在编写一个提供松散耦合消息传递系统,也可以说你正在编写名称为 观察者 模式。用较小示例...
  • 设计模式 一书将设计模式引入软件社区,该书作者是 Erich Gamma、Richard Helm、Ralph Johnson 和 John Vlissides Design(俗称 “四人帮”)。所介绍的设计模式背后核心概念非常简单。经过多年软件开发实践,...
  • php常见五种设计模式

    2018-07-30 20:21:00
    一、常见的设计模式主要有23,根据使用目标的不同可以分为以下三大类:创建设计模式、结构设计模式、行为模式创建设计模式: (5)用于创建对象时的设计模式.初始化对象流程的设计模式.当程序复杂时,需要灵活创建对象...
  • 编者注 :请参阅后续文章“另外五种PHP设计模式 ”以了解可能会有用的五种其他设计模式设计模式被引入到设计模式的软件社区,由Erich Gamma,理查德头盔,拉尔夫·约翰逊和约翰·弗利赛德斯(俗称为“四人帮”...
  • 五种常见的 PHP 设计模式
  • 本文基于《JavaScript设计模式与开发实践》一书,用一些例子总结一下JS常见的设计模式与实现方法。文章略长,自备瓜子板凳~   设计原则 单一职责原则(SRP) 一个对象或方法只做一件事情。如果一个方法承担了...
  • PHP五种常见的设计模式策略模式工厂模式 策略模式 策略模式是对象的行为模式,用意是对__一组算法的封装__。动态的选择需要的算法并使用。 策略模式指的是程序中__涉及决策控制__的一种模式。策略模式功能非常强大,...
  • 设计模式只是为Java架构师准备——至少您可能一直这样认为。实际上,设计模式对于每个人都非常有用。如果这些工具不是 “架构太空人” 专利,那么它们又是什么?为什么说它们在PHP应用程序中非常有用?本文解释...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 836
精华内容 334
关键字:

常见的五种设计模式