-
单例模式用于：
不重复建立对象，节省内存。（PHP很容易卡死的，比如说递归20，30 层）比如用于数据库连接对象
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
|
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; }
} |
2.工厂模式用于：
应该TP里面的M方法建立迷行应该就是这样，感觉和单例还是很像的。
工厂模式就是一种类，具有为您创建对象的某些方法，这样就可以使用工厂类创建对象，而不直接使用new。这样如果想更改创建的对象类型，只需更改该工厂即可。
|
1
2
3
4
5
6
7
8
|
class Factory {//创建一个基本的工厂类
static public function fac($id){//创建一个返回对象实例的静态方法
if(1 == $id) return new A();
elseif(2==$id) return new B();
elseif(3==$id) return new C();
return new D();
}
}
|
3.观察者模式：
针对一个博主，这是一个接口或者对象，里面可以注册观察者（关注者），然后遍历关注者，对每个人执行一个方法。例如这个样子：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
|
<?php //主题
class Paper{
private $_observers = array();
//注冊观察者,谁依赖我,谁是我的粉丝，我有动态，依次推送，都在观察关注我
public function register($sub){
$this->_observers[] = $sub;
}
//外部统一访问
public function trigger(){
if(!empty($this->_observers)){
foreach($this->_observers as $observer){
$observer->update();//统一的方法，依次进行各个观察者
}
}
}
}
//观察者实现接口
interface Observerable{
public function update();
}
class Subscriber implements Observerable{
public function update(){
echo "Callback\n";
}
}
$paper = new Paper();
$paper->register(new Subscriber());
$paper->trigger();
|
4.策略模式
针对同一个行为，你有不同的方案，就可以写成策略，就是一个大的算法集合。再比如你定价有不同的活动，满200-10，满400-100等，都是一个小算法，集合成策略
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
|
<?php interface FlyBehavior{
//策略接口
public function fly();
}
class FlyWithWings implements FlyBehavior{
//c策略1
public function fly(){
echo "Fly with Wings";
}
}
class FlyWithNo implements FlyBehavior{
//c策略2
public function fly(){
echo "Fly with No Wings";
}
}
class Duck{
private $_flyBehavior;
public function performFly(){
$this->_flyBehavior->fly();
}
//这里引进来策略，可以切换不同的策略
public function setFlyBehavior(FlyBehavior $behavior){
$this->_flyBehavior = $behavior;
}
}
class RubberDuck extends Duck{
}
$duck = new RubberDuck();
$duck->setFlyBehavior(new FlyWithWings());
$duck->performFly();
$duck->setFlyBehavior(new FlyWithWings());
$duck->performFly();
|
5.装饰者模式
就是给被装饰者增加属性的，之后你就可以取代被装饰者。其实一个明显的例子就是穿衣服的顺序和方案。因为你有很多的方案可以动态加进去。这样的话比生成子类好很多，就不用把每个方案都建立对象，然后执行方法。
不恰当的示例如下：
$a = new a(new person());
$a.show();
$b=new b(new person());
$b.show();
$c = new c(new person());
$c.show();
改进的方案如下：首先把a,b，c 写一个抽象的接口统一起来，然后在面对被装饰者person()
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
|
<?php //抽象类不能实例化
abstract class Beverage{
public $_name;//品类名
abstract public function Cost();//费用
}
//被装饰者,都是给coffee加东西
class Coffee extends Beverage{
public function __construct(){
$this->_name = 'Coffee';//品类名
}
public function Cost(){
return 1.00;//原味咖啡的底价
}
}
//以下三个类是装饰者相关类
class CondimentDecorator extends Beverage{
public function __construct(){
$this->_name = 'Condiment';
}
public function Cost(){
return 0.1;
}
}
class Milk extends CondimentDecorator{
public $_beverage;//被装饰者
public function __construct($beverage){
$this->_name = 'Milk';//该品种名
if($beverage instanceof Beverage){
$this->_beverage = $beverage;
}else{
exit('Failure');
}
}
public function Cost(){
return $this->_beverage->Cost()+0.2;//底价加上新加的东西
}
}
class Sugar extends CondimentDecorator{
public $_beverage;//被装饰者
public function __construct($beverage){
$this->_name = 'Sugar';//该品种名
if($beverage instanceof Beverage){
$this->_beverage = $beverage;
}else{
exit('Failure');
}
}
public function Cost(){
return $this->_beverage->Cost()+0.2;//底价加上新加的东西
}
}
//拿杯咖啡
$coffee = new Coffee();
//加点牛奶
$coffee = new Milk($coffee);
//加点糖
$coffee = new Sugar($coffee);
echo "Coffee现在的总价格是".$coffee->Cost();
//总结：
//1.装饰者和被装饰者必须是同一类型，因为装饰者可以取代它
//2.当装饰者和组件组合的时候，就是在加入新的行为
|
本文转自 jackdongting 51CTO博客，原文链接:http://blog.51cto.com/10725691/1954572