HI Guys , In this article we are feeding the observer design pattern into our brain.

Definition of Observer design pattern

An observer design pattern is a one-to-many relationship between the objects when one object changes the state all other objects are will get notified and updated automatically.

Oho, you might think let's close this article he started with some object orient jargons I don't want to scare you with the definition but better to put to understand it with simplicity in the coming section.

So let's understand the observer design pattern using the newspaper example

There are two actors present in the newspaper publisher take the example of the times of India.

and the second actor is readers like you and me or some organization like a hotel, hospital airline, etc.

Reader subscribes the newspapers afterward gets the newspaper every day in the morning.

If the reader decides he/she wants to unsubscribe they can. After unsubscription, they will not get the newspaper but the other reader will have it right.

While newspaper publishers remains in the business and other readers like hotel, hospital, airlines will still get the news update till they have subscribed to the newspaper

If you understand the Newspaper subscription model. then you pretty much understand the observer design pattern.

only we call publisher as subject and subscriber as Observers

Publisher +Subscriber = Observer pattern

Let's take a closer look.

Suppose some object manages some bit of information lets call int a

and some groups of objects are interested to get notification when int a gets changes and do some kind of processing on that basis.

In that case, the object which holds the bit of information is called the subject and the group of objects is observers.

Observers can decide if they want to get notified by subscribing to the subject-object and at any point in time observer object can unsubscribe to leave the observer group

let's see the below diagram where subject-object managing the int a data and dog, cat , mouse object subscribes to the subject so whenever the state a will changes dog cat and mouse object will get a notification. In other words cats, dog and mouse are observers of subject-object. on the other hand, duck object is not subscribed to the subject object so it will not get any notification

Now you all understand, what exactly the observer pattern is.

You also got glimpses at what situation we can apply this pattern in the real world. Let me reiterate the situation of applicability of pattern. suppose we have a situation where we have some remote object which maintains the state. and some bunch of objects wants to get notification when that state changes. so we can use observer design patterns to solve the problem.

You must be having the question of how can we implement this pattern in a real-world examples. Before that let's go through the class diagram of the observer design pattern

In the above class diagram, we have two interface

• Subject
• Observer

Subject Interface contains the add, remove and notify functionality which can use to add remove and notify the observers on runtime.

Concrete observers should implement the Observer interface which has method updates. So whenever the subject update its state then the subject will notify the changing state to the observer by calling its update method

Let's implement the observer design pattern by taking the example Let's assume we have to design a system where one component tracks the changes in temperature and some components need the active changes temperature value so they can behave on the basis of temperature value and control the system to work in the proper way at different temperatures.

So in the case, we need one Subject which tract the temperature value and observers who will observe the temperature value from subject and act accordingly

Subject interface

public interface Subject {
    void registerObserver(IObserver iObserver);
    void removeObserver(IObserver iObserver);
    void notifyStateChange();

}

Concrete Temperature Subject implement Subject interface

import java.util.ArrayList;

public class TemperatureSubject implements  Subject
{
    private  final ArrayList<IObserver> observers;
    private final State state ;

    public TemperatureSubject() {
        state =new State();
        observers= new ArrayList<>();
    }

    @Override
    public void registerObserver(IObserver iObserver) {
        observers.add(iObserver);
    }

    @Override
    public void removeObserver(IObserver iObserver) {


        if(observers.indexOf(iObserver)>-1){
            observers.remove(iObserver);
        }
    }

    public  void  setTemprature(int temprature){
        state.setTemperature(temprature);
        notifyStateChange();
    }
    @Override
    public void notifyStateChange() {

        observers.stream().forEach(observer-> observer.update(state));

    }
}

Registration the Subject with Observers and change the temperature

public class Main {

    public static void main(String[] args) {

     //create subject
     TemperatureSubject subject = new TemperatureSubject();

     //create observers and register them with subject
     TemperatureObserver observer1= new TemperatureObserver(subject,"observer-1");
     TemperatureObserver observer2= new TemperatureObserver(subject,"observer-2");

  //change the state of subject and from there subject will notify the observers

     subject.setTemprature(10);
     System.out.println("------------------------------------------");
     subject.setTemprature(30);
     System.out.println("------------------------------------------");

     //observer1 going to unsubscribe for notification
     observer1.unSubscribe();
     //in this  case only subscriber 2 ca receive the notification
     subject.setTemprature(80);

    }
}

Output :

observer-1 :temperature change :10 c
observer-2 :temperature change :10 c
------------------------------------------
observer-1 :temperature change :30 c
observer-2 :temperature change :30 c
------------------------------------------
observer-2 :temperature change :80 c

Once the observer unsubscribe then he will not receive any notification from the subject

but at any time observer decide to register he can do register as he has reference if subject.

that the biggest benefit of the observer design pattern

Observer design pattern creates loosely coupled design. At any time observers can register and unregister without changing a single line of code in subject or observer.

I hope you get the idea of the observer design pattern.

Remember the Design Principle : Strive for the loosely couple design between the objects that interact

Thanks for reading