常见的php模式

php中6种常见的设计模式

• 单例模式
• 观察者模式
• 策略模式
• 工厂模式
• 注册模式
• 适配器模式

单例模式

Db.php
<?php
/**
* 单例模式
*/
class Db
{
    private static $instance=null;
    //私有的构造方法防止外界实例化对象
    private function __construct($className)
    {
 
    }
    //私有的克隆方法防止克隆
    private function __clone(){
    }
    //单例模式统一入口
    public static  function getInstance(){
        if (!(self::$instance instanceof self))
        {
            self::$instance = new self();
        }
        return self::$instance;
    }
}
 ?>

工厂模式

　　这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式。

　　在工厂模式中，我们在创建对象时不会对客户端暴露创建逻辑，并且是通过使用一个共同的接口来指向新创建的对象。

　　工厂模式下可以设立多个子工厂，而不是所有的产品有单一的工厂来生产，而是给各自特色的子工厂来生产。

优点：

1、一个调用者想创建一个对象，只要知道其名称就可以了。

2、扩展性高，如果想增加一个产品，只要扩展一个工厂类就可以。

3、屏蔽产品的具体实现，调用者只关心产品的接口。

<?php
 
interface Transport{
    public function go();
 
}
 
class Bus implements Transport{
    public function go(){
        echo "bus每一站都要停";
    }
}
 
class Car implements Transport{
    public function go(){
        echo "car跑的飞快";
    }
}
 
class Bike implements Transport{
    public function go(){
        echo "bike比较慢";
    }
}
 
class transFactory{
    public static function factory($transport)
    {
 
        switch ($transport) {
            case 'bus':
                return new Bus();
                break;
 
            case 'car':
                return new Car();
                break;
            case 'bike':
                return new Bike();
                break;
        }
    }
}
 
$transport=transFactory::factory('car');
$transport->go();

策略模式：

　　策略模式定义了一系列的算法，并将每一个算法封装起来，使每个算法可以相互替代，使算法本身和使用算法的客户端分割开来，相互独立

优点:

（1）上下文和具体策略是松耦合关系。因此上下文只知道它要使用某一个实现Strategy接口类的实例，但不需要知道具体是哪一个类。

（2）策略模式满足“开-闭原则”。当增加新的具体策略时，不需要修改上下文类的代码，上下文就可以引用新的具体策略的实例。

　　

<?php
interface jisuan{
    public function way($a,$b);
}
class jiajisuan implements jisuan{
    public function way($a,$b){
        echo $a+$b;
    }
}
class jianjisuan implements jisuan{
    public function way($a,$b){
        echo $a-$b;
    }
}
class chengjisuan implements jisuan{
    public function way($a,$b){
        echo $a*$b;
    }
}
class suanfa{
    private $a;
    private $b;
    public $_obj;
    public function __construct($a,$b){
        $this->a=$a;
        $this->b=$b;
    }
    public function caozuo($obj){
        $this->_obj=new $obj;
        return $this->_obj->way($this->a,$this->b);
    }
}
$suanfa =new suanfa(,);
$suanfa->caozuo("chengjisuan");
?>

观察者模式

观察者模式(Observer),当一个对象的状态发生改变时，依赖他的对象会全部收到通知，并自动更新。

场景：一个事件发生后,要执行一连串更新操作.传统的编程方式,就是在事件的代码之后直接加入处理逻辑,当更新得逻辑增多之后,代码会变得难以维护.这种方式是耦合的,侵入式的,增加新的逻辑需要改变事件主题的代码

优点：

观察者模式实现了低耦合,非侵入式的通知与更新机制

<?php 
 
/**
观察者模式
定义一个接口实现两个方法
第一个方法进行注入初始化数组(传进去的参数是一个实例化后的对象数组比如猫对象)
数组内饰猫对象、狗对象、人对象
第二个方法进行通知因为传进来的是一个一维数组
遍历一维数组分别调用watch算法接受到通知
*/
/*定义观察者接口*/
interface aa{
    public function watch();
}
/*实现观察者接口*/
class cat implements aa{
    public function watch(){
        echo "cat 已经收到";
    }
}
class dog implements aa{
    public function watch(){
        echo "dog 已经收到";
    }
}
class people implements aa{
    public function watch(){
        echo "people 已经收到";
    }
}
/*定义bb接口*/
interface bb{
    /*注册接口*/
    public function register($obj);
    /*同志接口*/
    public function notify();
}
/*实现bb接口*/
class Action implements bb
{
 
    public $_obj=[];
    public function register($obj){
        var_dump($obj);
        $this->_obj[]=$obj;
    }
    public function notify(){
        foreach($this->_obj as $ob){
            $ob->watch();
        }
    }
}
$action=new Action();
$action->register(new cat());
$action->register(new dog());
$action->register(new people());
$action->notify();
 ?>