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. ?>