php 设计模式
php设计模式
单例模式
只有一个实例，作为对象的创建模式，单例模式确保某一个类只有一个实例，而且自行实例化并向整个系统提供这个实例
/**
设计模式值单例模式
$_instance必须声明为静态的私有变量
构造函数必须声明为私有，防止外部程序new类从而失去单例模式的意义
getInstance()方法必须设置为共有的，必须调用此方法以返回实例的一个引用
::操作符只能访问静态变量和静态函数
new对象都会消耗内存
使用场景 最常用的地方是数据库连接
使用单例模式生成一个对象后，该对象可以被其他众多对象所使用
*/
class man
{
//保存实例在此属性中
private static $_instance;
//将构造函数声明为private,防止直接创建对象
private function __construct(){
echo "我被实例化了";
}
//单例方法
public static function get_instance(){
var_dump(isset(self::$_instance));
if(!isset(self::$_instance))
{
self::$_instance = new self();
}
return self::$_instance;
}
//阻止用户复制对象实例
private function __clone()
{
trigger_error('clone is not allow' , E_USER_ERROR);
}
function test(){
echo "test";
}
}
$test = man::get_instance();
$test = man::get_instance();
$test->test();
工厂模式
1）抽象基类：类中定义抽象一些方法，用以在子类中实现
2）集成自抽象基类的子类：实现基类中的抽象方法
3）工厂类：用以实例化所有相应的子类
abstract class Operation{
//抽象方法不能包含函数体
abstract public function getValue($num1,$num2); //要求子类实现该功能函数
}
//加法类
class OperationAdd extends Operation{
public function getValue($num1,$num2){
return $num1+$num2;
}
}
//除法类
class OperationDiv extends Operation{
public function getValue($num1,$num2){
try{
if($num2 == 0){
throw new Exception("除数不能为0");
}else{
return $num1/$num2;
}
}catch(Exception $e){
echo "错误信息：" . $e->getMessage();
}
}
}
通过采用面向对象的继承特性，我们可以很容易就能对原有程序进行扩展，比如乘方 开方
现在还有一个问题未解决，就是如何让程序根据用户输入的操作符实例化相应的对象呢
解决办法：使用一个单独的类来实现实例化的过程，这个类就是工厂
/**
* 工程类，主要用来创建对象
* 功能：根据输入的运算符号，工厂就能实例化出合适的对象
class Factory{
public static function createObj($operate){
switch($operate){
case '+':
return new OperationAdd();
break;
case '-':
return new OperationSub();
break;
case '/':
return new OperationDiv();
break;
}
}
}
$test = Factory::createObj('/');
$result = $test->getValue(23,0);
echo $result;
观察者模式
观察者墨水为您提供了避免组件之间紧密耦合的另一种方法。该模式非常简单：一个对象通过添加一个方法（该方法允许另一个对象，即观察者注册自己）使本身变得可观察。当可观察的对象更改时，它会将消息发送到已注册的观察者。这些观察者使用该信息执行的操作与可观察的对象无关。结果是对象可以相互对话，而不必了解原因
一个简单示例是系统中的用户列表。下例中的代码显示一个用户列表，添加用户时它将发送出一条消息。添加用户时通过发送消息的日志观察者可以观察此列表
Observer.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\n";
}
}
$ul = new UserList();
$ul->addObserver(new UserListLogger());
$ul->addCustomer("jack");
策略者模式
在此模式中，算法是从复杂类提取的，因而可以方便地替换。例如，如要更改搜索引擎中排列页的方法，则策略模式是一个不错的选择，思考一下搜索引擎的几个部分——一部分遍历页面，一部分对每页排列，另一部分基于排列的结果排序。在复杂的示例中，这些部分都在同一个类中，通过使用策略模式，可以将排列部分放入另一个类中，以便更改页排列的方式，而不影响搜索引擎的其余代码
作为一个较简单的示例，下面显示了一个用户列表类，它提供了一个根据一组即插即用的策略查找一组用户的方法
//定义接口
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;
}
}
//实现接口方式1
class RandomStrategy implements IStrategy{
public function filter($record){
return rand(0,1)>=0.5;
}
}
//主类
class UserList{
private $_list = array();
public function __construct($names){
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());
策略模式非常适合复杂数据管理系统或数据处理系统，二者在数据筛选、搜索或处理的方式方面需要较高的灵活性