1.抽象工厂模式
<?php
//抽象工厂模式
//开闭原则:对类的新增开放,对类的修改关闭。
class MySQL{
}
class Sqlite{
}
class MyPDO{
}
//定义一个接口
interface Factory{
public static function getDB();
}
class MySQLFactory implements Factory{
public static function getDB(){
return new MySQL();
}
}
class SqliteFactory implements Factory{
public static function getDB(){
return new Sqlite();
}
}
class MyPDOFactory implements Factory{
public static function getDB(){
return new MyPDO();
}
}
$db=MyPDOFactory::getDB();
print_r($db); //MyPDO Object ( )
?>
2.单例模式
<?php
//单例模式
/**
* 两点要求
* 1.不能被外界实例化,因为一旦可以实例化,那将可以生产多个对象,那就肯定不是单例
* 2.需要用静态成员方法来创建对象,静态成员方法可以脱离对象而工作
* 3.在静态成员方法中创建对象时加入判断(实例对象是否已经创建),来确保只有一个对象产生
*/
class Single{
protected $rnd;
protected static $ins=null;//用于存储创建的实例对象
//protected 关键字修饰构造函数的用意在于外界不能实例化此类
protected function __construct(){
$this->rnd=mt_rand(10000,99999);
}
//获取实例,使用static修饰,用意在于不依赖对象就可以工作
public static function getIns(){
//此处的判断,保证了只有一个对象的产生
if(self::$ins===null){
self::$ins=new self();
}
return self::$ins;
}
}
$s1=Single::getIns();
$s2=Single::getIns();
var_dump($s1===$s2); //bool(true),此结果说明二者是同一个对象
?>
3.责任链模式
<?php
//责任链模式
//示例 论坛举报功能
/**
* [举报]:粗口 黄赌毒 反政府
* [处理人] 版主 警察 国安
*/
class Admin{
public function __construct(){
if($this->top===null){
return;
}
$this->toper=new $this->top();
}
public function proc($danger){
if($danger<=$this->power){
$this->doProc();
}else{
$this->toper->proc($danger);
}
}
}
class Banzhu extends Admin{
protected $power=1;
protected $top='Police';
protected function doProc(){
echo "删帖";
}
}
class Police extends Admin{
protected $power=2;
protected $top='Guoan';
public function doProc(){
echo "抓人";
}
}
class Guoan extends Admin{
protected $power=3;
protected $top=null;
public function doProc(){
echo "灭口";
}
}
$danger=1;
$Banzhu=new Banzhu();
$Banzhu->proc($danger);//删帖
$danger=2;
$Banzhu=new Banzhu();
$Banzhu->proc($danger);//抓人
$danger=3;
$Banzhu=new Banzhu();
$Banzhu->proc($danger);//灭口
?>