Posted on by John

PHP设计模式实例之(观察者模式、策略模式、简单工厂模式)

观察者模式

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
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
<?php
/**
* 定义观察接口
*/
interface Subject
{
    public function Attach($Observer); //添加观察者
    public function Detach($Observer); //踢出观察者
    public function Notify(); //满足条件时通知观察者
    public function SubjectState($Subject); //观察条件
}
 
/**
* 观察类的具体实现
*/
class Boss Implements Subject
{
    public $_action;
    
    private $_Observer;
    
    public function Attach($Observer)
    {
        $this->_Observer[] = $Observer;
    }
    
    public function Detach($Observer)
    {
        $ObserverKey = array_search($Observer, $this->_Observer);
        
        if($ObserverKey !== false)
        {
            unset($this->_Observer[$ObserverKey]);
        }
    }
    
    public function Notify()
    {
        foreach($this->_Observer as $value )
        {
            $value->Update();
        }
    }
    
    public function SubjectState($Subject)
    {
        $this->_action = $Subject;
    }
}
 
/**
* 抽象观察者
*
*/
abstract class Observer
{
    protected $_UserName;
    
    protected $_Sub;
    
    public function __construct($Name,$Sub)
    {
        $this->_UserName = $Name;
        $this->_Sub = $Sub;
    }
    
    public abstract function Update(); //接收通过方法
}
 
/**
* 观察者
*/
class StockObserver extends Observer
{
    public function __construct($name,$sub)
    {
        parent::__construct($name,$sub);
    }
    
    public function Update()
    {
        echo $this->_Sub->_action.$this->_UserName." 你赶快跑...";
    }
}
 
$huhansan = new Boss(); //被观察者
$gongshil = new StockObserver("三毛",$huhansan); //初始化观察者
$huhansan->Attach($gongshil); //添加一个观察者
$huhansan->Attach($gongshil); //添加一个相同的观察者
$huhansan->Detach($gongshil); //踢出基中一个观察者
$huhansan->SubjectState("警察来了"); //达到满足的条件
$huhansan->Notify(); //通过所有有效的观察者
?>

策略模式

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
/**
* 定义支持算法的接口
*
*/
abstract class Strategy
{
    abstract public function AlgorithmInterface();
}
 
class ConcreateStratA extends Strategy
{
    public function AlgorithmInterface()
    {
        echo "算法A";
    }
}
 
class ConcreateStratB extends Strategy
{
    public function AlgorithmInterface()
    {
        echo "算法B";
    }
}
 
 
class ConcreateStratC extends Strategy
{
    public function AlgorithmInterface()
    {
        echo "算法C";
    }
}
 
class Context
{
    private $_StrObj;
    
    public function __construct($strobj)
    {
        $this->_StrObj = $strobj;
    }
    
    public function ContextInterface()
    {
        $this->_StrObj->AlgorithmInterface();
    }
}
 
$context = new Context(new ConcreateStratA);
$context->ContextInterface();
$context = new Context(new ConcreateStratC);
$context->ContextInterface();
$context = new Context(new ConcreateStratB);
$context->ContextInterface();

简单工厂模式

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
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
/**
* 定义运算类
*
*/
abstract class Operation
{
    //存储第一个数字
    protected $_NumberA = 0;
    
    //存储第二个数字
    protected $_NumberB = 0;
    
    //存储运算结果
    protected $_Result = 0;
    
    public function __construct()
    {
        //empty
    }
    
    /**
     * 设定需要运行的二个数字
     *
     * @param 第一个数字 $A
     * @param 第二个数字 $B
     */
    public function SetNumber($A=0,$B=0)
    {
        $this->_NumberA = $A;
        $this->_NumberB = $B;
    }
    
    /**
     * 清除所有数据
     *
     */
    protected function ClearResult()
    {
        $this->_Result = 0;
    }
    
    abstract function GetResult();
}
 
 
/**
* 数据相加
*/
class OperactionAdd extends Operation
{
    public function GetResult()
    {
        $this->_Result = $this->_NumberA + $this->_NumberB;
        
        return $this->_Result;
    }
}
 
 
/**
* 数据相减
*/
class OperactionSub extends Operation
{
    public function GetResult()
    {
        $this->_Result = $this->_NumberA - $this->_NumberB;
        
        return $this->_Result;
    }
}
 
 
/**
* 数据相乘
*/
class OperactionMul extends Operation
{
    public function GetResult()
    {
        $this->_Result = $this->_NumberA * $this->_NumberB;
        
        return $this->_Result;
    }
}
 
 
/**
* 数据相除
*/
class OperactionDiv extends Operation
{
    public function GetResult()
    {
        $this->_Result = $this->_NumberA / $this->_NumberB;
        
        return $this->_Result;
    }
}
 
class OperactionFactory
{
    private static $_Obj;
    
    public static function CreateOperaction($type)
    {
         switch($type)
         {
             case "+":
                 self::$_Obj = new OperactionAdd;
                 break;
             case "-":
                 self::$_Obj = new OperactionSub;
                 break;
             case "*":
                 self::$_Obj = new OperactionMul;
                 break;
             case "/":
                 self::$_Obj = new OperactionDiv;
                 break;
         }
        
         return self::$_Obj;
    }
}
 
$Obj = OperactionFactory::CreateOperaction("*");
$Obj->SetNumber(6,4);
$num = $Obj->GetResult();
var_dump($num);

 

 

 

 

Leave a Reply

Your email address will not be published.