Observer Pattern

An Observer Pattern says that "just define a one-to-one dependency so that when one object changes state, all its dependents are notified and updated automatically".

The Memento pattern is also known as Dependents or Publish-Subscribe.

---

Benefits:

• It describes the coupling between the objects and the observer. Loosely coupled objects are flexible with changing requirements. Here loose coupling means that the interacting objects should have less information about each other.
  Observer pattern provides this loose coupling as:
  • Subject only knows that observer implement Observer interface.Nothing more.
  • There is no need to modify Subject to add or remove observers.
  • We can reuse subject and observer classes independently of each other.
• It provides the support for broadcast-type communication.

Disadvantage:

• Memory leaks caused by Lapsed listener problem because of explicit register and unregistering of observers.

---

Usage:

• You should consider using this pattern in your application when multiple objects are dependent on the state of one object as it provides a neat and well tested design for the same.
• When the framework we writes and needs to be enhanced in future with new observers with minimal changes.

New Class Diagram:
 

Java Implementation:

// Java program to demonstrate working of // onserver pattern import java.util.ArrayList;    // 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 (Observer o : observerList) {             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("\nAverage Score Display: \n"                            + "Run Rate: " + runRate +                            "\nPredictedScore: " +                            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("\nCurrent Score Display:\n"                            + "Runs: " + runs +                            "\nWickets:" + wickets +                            "\nOvers: " + 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();     } }

Output:

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

Reference: https://www.geeksforgeeks.org/observer-pattern-set-2-implementation/