observer and observable in java example

observer and observable in java example

I'm happy to help!

Observer Design Pattern: A Simple Java Example

The Observer design pattern is a behavioral pattern that allows an object (the subject or observable) to notify other objects (observers) when its state changes.

Here's a simple example in Java:

// The Subject, Observable class
public interface Subject {
void registerObserver(Observer observer);
void removeObserver(Observer observer);
void notifyObservers();
}
// The Observer class
public abstract class Observer {
protected String name;
public Observer(String name) {
this.name = name;
}
// Define an update method which will receive the notification
public abstract void update();
}
// A specific ConcreteObserver for Temperature
public class TemperatureObserver extends Observer {
public TemperatureObserver(String name) {
super(name);
}
@Override
public void update() {
System.out.println("TemperatureObserver: Temperature has changed!");
}
}
// Another specific ConcreteObserver for Humidity
public class HumidityObserver extends Observer {
public HumidityObserver(String name) {
super(name);
}
@Override
public void update() {
System.out.println("HumidityObserver: Humidity has changed!");
}
}
// The WeatherStation, which is the subject observable
public class WeatherStation implements Subject {
private List observers;
private int temperature;
public WeatherStation() {
this.observers = new ArrayList<>();
this.temperature = 0;
}
@Override
public void registerObserver(Observer observer) {
this.observers.add(observer);
}
@Override
public void removeObserver(Observer observer) {
this.observers.remove(observer);
}
@Override
public void notifyObservers() {
for (Observer observer : observers) {
observer.update();
}
}
// The actual weather station logic goes here...
public void setTemperature(int temperature) {
System.out.println("WeatherStation: Temperature has changed to " + temperature);
this.temperature = temperature;
notifyObservers(); // Notify all registered observers
}
}
public class Main {
public static void main(String[] args) {
WeatherStation weatherStation = new WeatherStation();
TemperatureObserver tempObserver = new TemperatureObserver("Temp Observer");
HumidityObserver humidityObserver = new HumidityObserver("Humidity Observer");
weatherStation.registerObserver(tempObserver);
weatherStation.registerObserver(humidityObserver);
// Simulate temperature change
weatherStation.setTemperature(30);
// Simulate another temperature change
weatherStation.setTemperature(20);
// Remove the temperature observer, no notifications should be sent for this change
weatherStation.removeObserver(tempObserver);
// Another temperature change after removing tempObserver
weatherStation.setTemperature(10);
}
}

This example demonstrates how multiple observers (TemperatureObserver and HumidityObserver) can register themselves with a subject (WeatherStation). When the WeatherStation's state changes, it notifies all registered observers by calling their update methods.

The key benefits of this design pattern are:

In the provided example, when the temperature in WeatherStation changes, it notifies all registered TemperatureObserver and HumidityObserver instances.

java observer pattern vs listener

The Observer Pattern and the Listener (or Event Handling) pattern are two popular design patterns used to manage interactions between objects. While they share some similarities, they have distinct differences.

Observer Pattern:

In the Observer pattern, you have a subject (also known as the publisher or provider) that maintains a list of dependencies (observers). When the subject's state changes, it notifies all its observers, allowing them to react accordingly. This decouples the subject from the specific actions taken by the observers.

The Observer pattern is often used in situations where:

In Java, you can implement the Observer pattern using:

Listener (or Event Handling) pattern:

In the Listener pattern, an event source publishes events to one or more event listeners. Each listener is responsible for handling the received event. The event source does not know about the specific listeners; it only knows that there are listeners registered to receive its events.

The Listener pattern is often used in situations where:

In Java, you can implement the Listener pattern using:

Key differences:

When deciding between these two patterns:

In conclusion, while both patterns allow for object interactions and decoupling, they differ in their communication direction, responsibilities of participants, and use cases. By understanding these differences, you can select the most suitable pattern for your Java application's requirements.