oop的三种设计模式（单例、工厂、策略）
单例模式：
废话不多说，我们直接上代码：
<?php
/**
三私一公
*私有的静态属性：保存类的单例
*私有的__construct()：阻止在类的外部实例化
*私有的__clone()：阻止在类的外部clone对象
*共有的静态方法：获取类的单例
*/
class DanLi{
private static $instance; //保存类的单例
private function __construct() { //阻止在类的外部实例化
}
private function __clone() { //阻止在类的外部clone对象
}
//获取当前类的单例
public static function getInstance() {
if(!self::$instance instanceof self)//$instance中保存的不是MySQLDB类的单例就实例化
self::$instance=new self();
return self::$instance; //返回单例
}
}
//测试
$db1=DanLi::getInstance();
$db2=DanLi::getInstance();
var_dump($db1,$db2);
我们可以看到结果为下图：
我们可以看到，结果为：两个实例化出来对象是一样的。这就体现了我们单例的精髓（只能实例化出来一个实例，并且不可复制，能够节省系统资源）
注意:静态变量上存在内存中的，它不会因为程序执行完毕二消失，所以我们第二次实例化的时候，会检测到instance的存在，因而直接返回已经存在的instance实例。
下面我们来看一下单例的实际运用：用于数据库连接类，因为是数据库连接，我们没有必要每一次操作数据库都进行一次数据库类的实例化，那样会大大的消耗系统资源。所以，我们用到了单例模式，代码如下：
//初始化连接参数
private function initParam($config){
$this->host=isset($config['host'])?$config['host']:'';
$this->port=isset($config['port'])?$config['port']:'3306';
$this->user=isset($config['user'])?$config['user']:'';
$this->pwd=isset($config['pwd'])?$config['pwd']:'';
$this->charset=isset($config['charset'])?$config['charset']:'utf8';
$this->dbname=isset($config['dbname'])?$config['dbname']:'';
}
private function connect(){
$this->link=@mysql_connect("{$this->host}:{$this->port}",$this->user,$this->pwd) or die('数据库连接失败');
}
private function setCharset(){
$sql = "set names '{$this->charset}'";
$this->query($sql);
}
private function selectDB(){
$sql = "use `{$this->dbname}`";
$this->query($sql);
}
private function __construct($config){
$this->initParam($config);
$this->connect();
$this->setCharset();
$this->selectDB();
}
private function __clone(){
}
public static function getInstance($config=array()) {
if(!self::$instance instanceof self)
self::$instance=new self($config);
return self::$instance;
}
public function query($sql){
if(!$result=mysql_query($sql,$this->link)){
echo 'sql语句执行失败<br />';
exit;
}
return $result;
}
}
$config=array(
'host' => '127.0.0.1',
'user' => 'root',
'dbname' => 'accounts'
);
$db = Test::getInstance($config);
$sql = "select * from acc_wechat";
$info = $db->query($sql);
while($rows = mysql_fetch_row($info)){
//echo $rows[1].'<br>';
//var_dump($rows);
echo $rows[0].'-'.$rows[1].'<br />';
}
var_dump($info);
?>
通过以下代码，我们就大体了解了：单例的原理及实际运用。
工厂模式：
工厂模式可以这样来概括：工厂里面已经把你所需要的东西都准备好了，要什么自己拿就行。
集体实现代码如下：
<?php
//要实现的接口
interface BaseClass{
public function say();
}
//实现接口类1
class Man implements BaseClass{
function say(){
return 'I'm Man.';
}
}
//实现接口类2
class Women implements BaseClass{
function say(){
return 'I'm Women.';
}
}
//构建工厂类
class Factory{
public static function man(){
return new Man();
}
public static function Women(){
return new Women();
}
}
//获取工厂中Man这个类
$man=Factory::man();
//调用Man类中的say方法
$man->say();
//获取工厂中Women这个类
$women=Factory::women();
//调用Women类中的say方法
$women->say();
?>
以上就是工厂模式的实现过程。
策略模式：
这个我也不知道该怎么形容，直接上代码吧。
<?php
//接口类（抽象策略角色）
interface BaseClass{
public function name();
}
//实现接口类1（环境角色1（对抽象策略角色的引用））
class XiaoMing implements BaseClass{
function name(){
return 'My name is XiaoMing.';
}
}
//实现接口类2（环境角色2（对抽象策略角色的引用））
class XiaoHong implements BaseClass{
function name(){
reutrn 'My name is XiaoHong.';
}
}
//构建具体策略角色
class CeLve{
public function call($object){
return $object->name();
}
}
//实例化策略类
$obj = new CeLve();
//传入小明类并调用name方法,打印出结果
echo $obj->call(new XiaoMing());
//传入小红类并调用name方法，打印出结果
echo $obj->call(new XiaoHong());
?>
关于工厂模式和策略 模式，有以下总结。
该总结出自：简单工厂模式与策略模式的区别
工厂(Factory)模式我们可以做如下理解，假设有一个Audi的公司生产汽车（似乎也不用假设了），它掌握一项核心的技术就是生产汽车，另一方面，它生产的汽车是有不同型号的，并且在 不同的生产线上进行组装。当客户通过销售部门进行预定后，Audi公司将在指定的生产线上为客户生产出它所需要的汽车。
策略(Strategy)模式在结构上与工厂模式类似，唯一的区别是工厂模式实例化一个产品的操作是在服务端来做的 ，换句话说客户端传达给服务端的只是某种标识，服务端根据该标识实例化一个对象。而策略模式的客户端传达给服务端的是一个实例 ，服务端只是将该实例拿过去在服务端的环境里执行该实例的方法。这就好比一个对汽车不甚了解的人去买车，他在那一比划，说要什么什么样的，销售部门根据他的这个“比划”来形成一份订单，这就是工厂模式下的工作方式。而策略模式下那个顾客就是个行家，他自己给出了订单的详细信息，销售部门只是转了一下手就交给生产部门去做了。通过两相对比，我们不难发现，采用工厂模式必须提供足够灵活的销售部门，如果用户有了新的需求，销售部门必须马上意识到这样才可以做出合适的订单。所以倘一款新车出来了，生产部门和销售部门都需要更新，对顾客来说也需要更新对新车的描述所以需要改动的地方有三处。而策略模式中的销售部门工作比较固定，它只负责接受订单并执行特定的几个操作。当一款新车出来时，只需要对服务端的生产部门和客户端的代码进行更新，而不需要更新销售部门的代码。
技术支持：
简单工厂和策略的基础都是因为面向对象的封装与多态。他们实现的思想都是先设定一个抽象的模型并从该模型派生出符合不同客户需求的各种方法，并加以封装。
简单工厂模式可以与策略模式结合。
简单工厂模式需要客户端认识 工厂类 和 抽象类的方法。
而策略模式简单工厂模式的结合可以把客户端的判断封装在Context类的构造函数里，这样可以让客户端只需要认识 Context 类就行了，更降低了耦合度。
例如简单工厂模式：
$a=Factory::func('123');
$a->show();
客户需要知道工厂类的创建方法func与类名Factory.还需要知道返回的类继承的抽象类或者接口定义的方法show()的用法。
而策略模式中
$a=new Context(new aClass(123));
$a->show();
还是需要客户端认识Context类与传入构造函数的参数类，所以可以加以改造，将策略模式与简单工厂模式结合起来，让构造函数接受一个条件变量，在构造函数中根据这个变量来决定产生的具体实例。
$a = new Context(123);
$a->show();
客户只需要认识Context类就可以了。
策略模式的重点在于让算法家族间的算法可以相互替换，引起的变化不会影响到使用算法的客户。
