* A one-to-many dependency between objects should be defined without making the objects tightly coupled.

* It should be ensured that when one object changes state an open-ended number of dependent objects are updated automatically.

* It should be possible that one object can notify an open-ended number of other objects.

* Define `Subject` and `Observer` Objects

* When a subject changes state, all registered observers are notified and updated automatically.


- Subject (IObservable)

- provides an interface for attaching and detaching Observer objects.

- ConcreteSubject (WeatherData)

- knows its observers.

- sends a notification to its observers when its state changes

- Observer (IObserver)

- defines an updating interface for objects that should be notified of changes in a subject.

- ConcreteObserver (CurrentConditionDisplay)

- maintains a reference to a ConcreteSubject object

- implements the Observer updating interface to keep its state consistent with the subject's.

## Collaboration

- ConcreteSubject notifies its observers whenever a change occurs.

- After being notified, a ConcreteObserver object may query the subject for information.

- The Observer object that initiates the change request **postpone its update** until it gets a notification from the subject to avoid redundant updates.

* Notify can be called by Subject, Observer or by any other object.

* Abstract coupling between Subject and Observer.

* Subject is not coupled to concrete classes. All a subject knows is that it has a list of observers, each conforming to abstract `Observer` interface.

* Observers can be attached and detached dynamically.

* Support for broadcast communication

* The subject doesn't care how many interested objects exist. The notification is broadcast automatically to all of them. It's up to the observer to handle or ignore a notification.

* Observers are notified in random order.

* Unexpected updates

* A seemingly innocuous operation on the subject may cause a cascade of updates to observers and their dependent objects.

* If dependency criteria aren't well-defined or maintained, it can lead to spurious updates, which can be hard to track down.

- **Mediator** - By encapsulating complex update semantics, the ChangeManager acts as mediator between subjects and observers.

- **Singleton**: The ChangeManager may use the Singleton pattern to make it unique and globally accessible.