观察者模式|集2（实现）-yiteyi-C++库

我们强烈建议在继续写这篇文章之前参考下面的第一集。

null

在集合1中，我们讨论了下面的问题，一个没有观察者模式的问题的解决方案，以及这个解决方案的问题。

假设我们正在构建一个板球应用程序，它会通知观众有关当前分数、跑步率等信息。假设我们制作了两个显示元素CurrentScoreDisplay和AverageScoreDisplay。CricketData拥有所有数据（跑步、保龄球等），每当数据更改时，显示元素都会收到新数据的通知，并相应地显示最新数据

将观察者模式应用于上述问题： 让我们看看如何使用观察者模式改进应用程序的设计。如果我们观察数据流，我们可以很容易地看到数据和显示元素遵循主题-观察者关系。

新类图：

Java实现：

                     // Java program to demonstrate working of                   
                     // onserver pattern                   
                     import                               java.util.ArrayList;                   
                     import                               java.util.Iterator;                   
                             
                     // Implemented by Cricket data to communicate                   
                     // with observers                   
                     interface                               Subject                   
                     {                   
                                         public                               void                               registerObserver(Observer o);                   
                                         public                               void                               unregisterObserver(Observer o);                   
                                         public                               void                               notifyObservers();                   
                     }                   
                             
                     class                               CricketData                               implements                               Subject                   
                     {                   
                                         int                               runs;                   
                                         int                               wickets;                   
                                         float                               overs;                   
                                         ArrayList<Observer> observerList;                   
                             
                                         public                               CricketData() {                   
                                         observerList =                               new                               ArrayList<Observer>();                   
                                         }                   
                             
                                         @Override                   
                                         public                               void                               registerObserver(Observer o) {                   
                                         observerList.add(o);                   
                                         }                   
                             
                                         @Override                   
                                         public                               void                               unregisterObserver(Observer o) {                   
                                         observerList.remove(observerList.indexOf(o));                   
                                         }                   
                             
                                         @Override                   
                                         public                               void                               notifyObservers()                   
                                         {                   
                                         for                               (Iterator<Observer> it =                   
                                         observerList.iterator(); it.hasNext();)                   
                                         {                   
                                         Observer o = it.next();                   
                                         o.update(runs,wickets,overs);                   
                                         }                   
                                         }                   
                             
                                         // get latest runs from stadium                   
                                         private                               int                               getLatestRuns()                   
                                         {                   
                                         // return 90 for simplicity                   
                                         return                               90                               ;                   
                                         }                   
                             
                                         // get latest wickets from stadium                   
                                         private                               int                               getLatestWickets()                   
                                         {                   
                                         // return 2 for simplicity                   
                                         return                               2                               ;                   
                                         }                   
                             
                                         // get latest overs from stadium                   
                                         private                               float                               getLatestOvers()                   
                                         {                   
                                         // return 90 for simplicity                   
                                         return                               (                               float                               )                               10.2                               ;                   
                                         }                   
                             
                                         // This method is used update displays                   
                                         // when data changes                   
                                         public                               void                               dataChanged()                   
                                         {                   
                                         //get latest data                   
                                         runs = getLatestRuns();                   
                                         wickets = getLatestWickets();                   
                                         overs = getLatestOvers();                   
                             
                                         notifyObservers();                   
                                         }                   
                     }                   
                             
                     // This interface is implemented by all those                   
                     // classes that are to be updated whenever there                   
                     // is an update from CricketData                   
                     interface                               Observer                   
                     {                   
                                         public                               void                               update(                               int                               runs,                               int                               wickets,                   
                                         float                               overs);                   
                     }                   
                             
                     class                               AverageScoreDisplay                               implements                               Observer                   
                     {                   
                                         private                               float                               runRate;                   
                                         private                               int                               predictedScore;                   
                             
                                         public                               void                               update(                               int                               runs,                               int                               wickets,                   
                                         float                               overs)                   
                                         {                   
                                         this                               .runRate =(                               float                               )runs/overs;                   
                                         this                               .predictedScore = (                               int                               )(                               this                               .runRate *                               50                               );                   
                                         display();                   
                                         }                   
                             
                                         public                               void                               display()                   
                                         {                   
                                         System.out.println(                               "Average Score Display: "                   
                                         +                               "Run Rate: "                               + runRate +                   
                                         "PredictedScore: "                               +                   
                                         predictedScore);                   
                                         }                   
                     }                   
                             
                     class                               CurrentScoreDisplay                               implements                               Observer                   
                     {                   
                                         private                               int                               runs, wickets;                   
                                         private                               float                               overs;                   
                             
                                         public                               void                               update(                               int                               runs,                               int                               wickets,                   
                                         float                               overs)                   
                                         {                   
                                         this                               .runs = runs;                   
                                         this                               .wickets = wickets;                   
                                         this                               .overs = overs;                   
                                         display();                   
                                         }                   
                             
                                         public                               void                               display()                   
                                         {                   
                                         System.out.println(                               "Current Score Display:"                   
                                         +                               "Runs: "                               + runs +                   
                                         "Wickets:"                               + wickets +                   
                                         "Overs: "                               + overs );                   
                                         }                   
                     }                   
                             
                     // Driver Class                   
                     class                               Main                   
                     {                   
                                         public                               static                               void                               main(String args[])                   
                                         {                   
                                         // create objects for testing                   
                                         AverageScoreDisplay averageScoreDisplay =                   
                                         new                               AverageScoreDisplay();                   
                                         CurrentScoreDisplay currentScoreDisplay =                   
                                         new                               CurrentScoreDisplay();                   
                             
                                         // pass the displays to Cricket data                   
                                         CricketData cricketData =                               new                               CricketData();                   
                             
                                         // register display elements                   
                                         cricketData.registerObserver(averageScoreDisplay);                   
                                         cricketData.registerObserver(currentScoreDisplay);                   
                             
                                         // in real app you would have some logic to                   
                                         // call this function when data changes                   
                                         cricketData.dataChanged();                   
                             
                                         //remove an observer                   
                                         cricketData.unregisterObserver(averageScoreDisplay);                   
                             
                                         // now only currentScoreDisplay gets the                   
                                         // notification                   
                                         cricketData.dataChanged();                   
                                         }                   
                     }                   

输出：

Average Score Display: 
Run Rate: 8.823529
PredictedScore: 441

Current Score Display:
Runs: 90
Wickets:2
Overs: 10.2

Current Score Display:
Runs: 90
Wickets:2
Overs: 10.2

注：现在我们可以在不改变主题的情况下添加/删除尽可能多的观察者。

参考资料：

https://en.wikipedia.org/wiki/Observer_pattern
首件设计模式手册（强烈推荐）

本文由 苏拉布·库马尔 .如果你喜欢GeekSforgek，并且想贡献自己的力量，你也可以写一篇文章，并将文章邮寄到contribute@geeksforgeeks.org.看到你的文章出现在Geeksforgeks主页上，并帮助其他极客。

如果您发现任何不正确的地方，或者您想分享有关上述主题的更多信息，请写评论

文章版权归作者所有，未经允许请勿转载。

THE END

技术文章