观察者模式（第四讲）

有一个数据处理类，处理完数据后（什么数据，什么数据都可以），需要通知数据绘制类在界面上绘制数据、数据存储类进行数据的存储。

实现如下：

Class DataDrawer

{

         void Draw();

}

 

Class DataSaver

{

         void Save();

}

 

Class DataProcessor

{

Private:

         DataSaver ds;      

         DataDrawer dd;

Public:

         void Proc();

         void Notify()

{

         ds.Save();

         dd.Draw();

}

}

Change1 : 数据误差处理（在原来的基础上添加一个需求）

则代码实现如下：

Version 1

Class DataErrorController

{

void ErrorControl();

}

Class DataDrawer

{

        void Draw();

}

Class DataSaver

{

        void Save();

}

 

Class DataProcessor

{

Private:

         DataSaver ds;      

         DataDrawer dd;

         DataErrorController dec;    //具体的东西变抽象？        继承

   

Public:

         void Proc();

         void Notify()

{

         dec.ErrorControl();

         ds.Save();

         dd.Draw();

}

}

Change2:  数据输出

则代码实现：在上一份代码的基础上添加一个DataOutputer类，该类中有Outputer方法，在DataProcessor类中声明一个DataOutputer的对象op，并在DataProcessor类的Notify方法中添加op.Outputer();代码

只要添加另外的需求，就会对代码进行如上类似的改动，其中违反了开闭原则，每次我们都对DataProcessor类的内部进行了修改

那么我们该如何对上述代码进行修改，才不会违反我们的原则？

代码实现如下：

Version 2

Class Observer

{

         Abstract void Update();

}

Class DataErrorController : public Observer

{

void ErrorControl();

void Update()

{

         ErrorControl();

}
}

Class DataDrawer:public Observer

{

         void Draw();

void Update()

{

         Draw ();

}

}

 

Class DataSaver:public Observer

{

         void Save();

void Update()

{

         Save ();

}

}

 

Class DataProcessor

{

Private:

         //Observer* ds;

         //Observer* dd;

         //Observer* dec;

         Vector<Observer*> pObs;

Public:

         void Proc();

         void Notify()//通知

{  

  //dec.ErrorControl();

  //ds.Save();

  //dd.Draw();

//接口统一：

  //pObs[0]->ErrorControl();

                  // pObs[1]->Save();

                  // pObs[2]->Draw();           

   

for(int I =0 I <pObs.GetSize(); i++)

         {

                   pObs[i]->Update();

 }

 

//Void Attach();

//void Detach();

void AddObserver(Observer* po)//添加观察者

{

pObs.push(po);
}

void RemoveObserver(int i)//移除观察者

{

         pObs->pop(i);

}

}

}

 

void main()

{

DataProcessor Dp;

DataSaver ds;

DataDrawer dd;

。。。。。。

 

Dp.AddObserver(&ds);

Dp.AddObserver(&dd);

Dp.Notify();

}

Version 1的类图如下：

Version 2 的类图如下：

总结：

观察这模式定义了一种一对多的依赖关系，让多个观察者对象同时监听某一个主题对象。这一个主题对象在状态发生变化时，会通知所有观察者对象，使他们能够自动更新自己