《Head First设计模式》读书笔记（一）

  用php来实现书中的示例和习题，昨天完成策略模式和观察者模式，代码如下：

1. <?php  
2.     interface FlyBehavior  
3.     {  
4.         function fly();  
5.     }  
6.     interface QuackBehavior  
7.     {  
8.         function quack();  
9.     }  
10.     class FlyWithWings implements FlyBehavior  
11.     {      
12.         public function fly()   
13.         {  
14.             print("fly with wings\n");  
15.         }  
16.     }  
17.     class FlyNoWay implements FlyBehavior  
18.     {  
19.         public function fly()  
20.         {  
21.             print("fly no way\n");  
22.         }  
23.     }  
24.     class Quack implements QuackBehavior  
25.     {  
26.         public function quack()  
27.         {          
28.             print("quack,gua,gua\n");  
29.         }  
30.     }  
31.     abstract class Duck  
32.     {  
33.         protected $flyBehavior = null;  
34.         protected $quackBehaviro = null;  
35.         public function __construct(FlyBehavior $flyBehavior = null, QuackBehavior $quackBehavior = null)  
36.         {  
37.             $this->setFlyBehavior($flyBehavior);  
38.             $this->setQuackBehavior($quackBehavior);  
39.         }  
40.         public function fly()   
41.         {  
42.             $this->flyBehavior->fly();  
43.         }  
44.         public function quack()  
45.         {  
46.             $this->quackBehavior->quack();      
47.         }  
48.         public function getFlyBehavior()  
49.         {  
50.             return $flyBehavior;  
51.         }  
52.         public function setFlyBehavior(FlyBehavior $fly)  
53.         {  
54.             $this->flyBehavior = $fly;  
55.         }  
56.         public function getQuackBehavior()  
57.         {  
58.             return $quackBehavior;  
59.         }  
60.         public function setQuackBehavior(QuackBehavior $quack)  
61.         {  
62.             $this->quackBehavior = $quack;  
63.         }  
64.         abstract public function display();  
65.     }  
66.     class RedheadDuck extends Duck  
67.     {  
68.         public function __construct(FlyBehavior $flyBehavior = null, QuackBehavior $quackBehavior = null)  
69.         {  
70.             parent::__construct($flyBehavior, $quackBehavior);  
71.         }  
72.         public function display()  
73.         {  
74.             print("damn it! RedheadDuck display()\n");  
75.         }  
76.     }  
77.     $duck = new RedheadDuck();  
78.     $duck->setFlyBehavior(new FlyWithWings());  
79.     $duck->setQuackBehavior(new Quack());  
80.     $duck->fly();  
81.     $duck->quack();  
82.     $duck->display();  
83. ?>  

 

1. <?php  
2.     abstract class Character  
3.     {  
4.         protected $weapon = null;  
5.         public function __construct(WeaponBehavior $weapon = null)  
6.         {  
7.             $this->setWeapon($weapon);  
8.         }  
9.         public function setWeapon(WeaponBehavior $weapon)  
10.         {  
11.             $this->weapon = $weapon;  
12.         }  
13.         public function getWeapon()  
14.         {  
15.             return $this->weapon;  
16.         }  
17.         public function useWeapon()  
18.         {  
19.             $this->weapon->useWeapon();  
20.         }  
21.     }  
22.     class Knight extends Character  
23.     {  
24.     }  
25.     class Queen extends Character  
26.     {  
27.     }  
28.     interface WeaponBehavior  
29.     {  
30.         function useWeapon();  
31.     }  
32.     class KnifeWeapon implements WeaponBehavior  
33.     {  
34.         public function useWeapon()  
35.         {  
36.             print("Knife used\n");  
37.         }  
38.     }  
39.     $man = new Knight();  
40.     $man->setWeapon(new KnifeWeapon());  
41.     $man->useWeapon();  
42. ?>  

 

1. <?php  
2.     interface Observable  
3.     {  
4.         function addObserver(Observer $observer);  
5.         function removeObserver(Observer $observer);  
6.         function notifyServers();  
7.     }  
8.     interface Observer  
9.     {  
10.         function update(WeatherData $weatherData);  
11.     }  
12.     class WeatherData implements Observable  
13.     {  
14.         private $observers = array();  
15.         private $temperature = 0;  
16.         private $humidity = 0;  
17.         private $pressure = 0;  
18.         public function getTemperature()  
19.         {  
20.             return $this->temperature;  
21.         }  
22.         public function setTemperature($temp)  
23.         {  
24.             $this->temperature = $temp;  
25.         }      
26.         public function getHumidity()  
27.         {  
28.             return $this->humidity;  
29.         }  
30.         public function setHumidity($humidity)  
31.         {  
32.             $this->humidity = $humidity;  
33.         }  
34.         public function getPressure()      
35.         {  
36.             return $this->pressure;  
37.         }  
38.         public function setPressure($pressure)  
39.         {      
40.             $this->pressure = $pressure;  
41.         }  
42.         public function setMeasurements($temperature, $humidity, $pressure)   
43.         {  
44.             $this->setTemperature($temperature);  
45.             $this->setHumidity($humidity);  
46.             $this->setPressure($pressure);  
47.             $this->measureChanged();              
48.         }  
49.         public function measureChanged()  
50.         {  
51.             $this->notifyServers();  
52.         }  
53.         public function addObserver(Observer $observer)  
54.         {  
55.             $this->observers[] = $observer;  
56.         }  
57.         public function removeObserver(Observer $observer)  
58.         {  
59.             $result = array();  
60.             foreach ($this->observers as $obj) {  
61.                 if ($obj !== $observer) {  
62.                     $result[] = $obj;  
63.                 }  
64.             }           
65.             unset($this->observers);  
66.             $this->observers = $result;  
67.         }  
68.         public function notifyServers()  
69.         {  
70.             foreach ($this->observers as $observer) {  
71.                 $observer->update($this);  
72.             }  
73.         }  
74.         public function getObservers()   
75.         {  
76.             return $this->observers;  
77.         }  
78.     }  
79.     interface Displayable  
80.     {  
81.         function display();  
82.     }  
83.     abstract class BaseDisplay implements Observer, Displayable  
84.     {  
85.         private $weatherData = null;   
86.         public function __construct(Observable $weatherData = null)  
87.         {  
88.             $this->weatherData = $weatherData;  
89.             if ($weatherData != null) {  
90.                 $this->weatherData->addObserver($this);  
91.             }  
92.         }  
93.         public function update(WeatherData $weatherData)  
94.         {  
95.         }  
96.         public function display()  
97.         {  
98.         }  
99.     }  
100.     class CurrentConditionDisplay extends BaseDisplay  
101.     {  
102.         private $weatherData = null;   
103.         private $temperature = 0;  
104.         private $humidity = 0;  
105.         private $pressure = 0;  
106.         public function __construct(Observable $weatherData = null)  
107.         {  
108.             $this->weatherData = $weatherData;  
109.             if ($weatherData != null) {  
110.                 $this->weatherData->addObserver($this);  
111.             }  
112.         }  
113.         public function update(WeatherData $weatherData)  
114.         {  
115.             $this->temperature = $weatherData->getTemperature();  
116.             $this->humidity = $weatherData->getHumidity();  
117.             $this->pressure = $weatherData->getPressure();  
118.             $this->display();      
119.         }          
120.         public function display()  
121.         {  
122.             print("temp: " . $this->temperature . ", humi: " . $this->humidity . ", pressure: " . $this->pressure . "\n");  
123.         }  
124.     }  
125.     class GeneralDisplay extends BaseDisplay  
126.     {  
127.           
128.         public function update(WeatherData $weatherData)  
129.         {  
130.             $this->display();      
131.         }  
132.         public function display()  
133.         {  
134.             print("GeneralDisplay().display\n");  
135.         }  
136.     }  
137.     $weatherData = new WeatherData();  
138.  
139.     $display = new CurrentConditionDisplay($weatherData);  
140.     $display2 = new GeneralDisplay($weatherData);  
141.     $weatherData->setMeasurements(20,30,40);  
142.     $weatherData->removeObserver($display2);  
143.     print("after...\n");  
144.     $weatherData->setMeasurements(33,44,55);  
145. ?>  

 

转载于:https://blog.51cto.com/phinecos/369028