The Observer pattern is a behavioral design pattern that defines a one-to-many dependency between objects so that when one object changes state, all its dependents are notified and updated automatically.

In Java, the Observer pattern is implemented using the built-in interfaces Observer and Observable. The Observable class represents the object being observed, while the Observer interface represents the objects that are observing the Observable.

To use the Observer pattern, you first define an Observable object and its corresponding Observer objects. The Observable object maintains a list of its observers, and when its state changes, it calls the notifyObservers() method to notify all its observers of the change. The Observer objects implement the update() method, which is called by the Observable object to update the observer with the new state.

For example, suppose you have a Stock class that represents a stock in a stock market. You could define an Observable subclass called StockMarket that maintains a list of Stock objects and notifies its observers when the prices of these stocks change.

You could then define an Observer interface called StockObserver that defines the update() method, which is called by the StockMarket object to update the observer with the new stock prices. Finally, you could define a Trader class that implements the StockObserver interface and receives notifications from the StockMarket object when the prices of the stocks it is interested in change.

In JDK there are many places where Observer design pattern is

used. Some of these are as follows:

1. java.util.Observer, java.util.Observable

2. javax.servlet.http.HttpSessionAttributeListener

3. javax.servlet.http.HttpSessionBindingListener

4. All implementations of java.util.EventListener, and also in

Swing packages

5. javax.faces.event.PhaseListener

https://howtodoinjava.com/design-patterns/behavioral/observer-design-pattern/#:~:text=A%20real%20world%20example%20of,at%20any%20point%20of%20time.