Observer Pattern

Part 3
Java Built-in Observer Pattern
 Java Built-in Observer
Pattern
• Java has several built-in observer pattern

• The general one exist in the util package

• java.util

• Subject/Observable: java.util.Observable

• http://developer.classpath.org/doc/java/util/Observable-source.html

• Observer: java.util.Observer

• http://developer.classpath.org/doc/java/util/Observer-source.html

• They are similar to our Subject & Observer, but give a lot of already built-in
functionalities

• In the observer you can choose push or pull for the update
Weather app Using Java-
built-in observer pattern

• Java built-in Observer is exactly as our observer

• Observable is class not interface like the Subject

• setChanged() didn’t exist in our Subject

Concrete Subject (WeatherData)
Using Java Built-in Observable
import java.util.Observable;

public class WeatherData extends Observable {

private float temperature;

private float humidity;

private float pressure;

public WeatherData() { }

• import the Observable

public void measurementsChanged() {

setChanged();

• The concrete Subject extends notifyObservers();}

the Observable (it is a class) public void setMeasurements(float temperature,

float humidity, float pressure) {

this.temperature = temperature;

this.humidity = humidity;

this.pressure = pressure;

measurementsChanged();}

//getter methods

}
Concrete Subject (WeatherData)
Using Java Built-in Observable
import java.util.Observable;

• No need to keep a list of public class WeatherData extends Observable {

private float temperature;

observers
private float humidity;

private float pressure;

• The constructor doesn’t need public WeatherData() { }

to create a data structure to

public void measurementsChanged() {

manage observers
setChanged();

notifyObservers();}

• The super class (Observable)

public void setMeasurements(float temperature,
will handle that
float humidity, float pressure) {

this.temperature = temperature;

• This means we don’t need to

this.humidity = humidity;

this.pressure = pressure;

manage addition/removal of measurementsChanged();}

observers //getter methods

}
Concrete Subject (WeatherData)
Using Java Built-in Observable
import java.util.Observable;

public class WeatherData extends Observable {

private float temperature;

• Java Observable has private float humidity;

setChanged() method to indicate private float pressure;

that there is a change, so we call public WeatherData() { }

this method first

public void measurementsChanged() {

setChanged();

• Then, call the notifyObserver()

notifyObservers();}

• Both setChanged and public void setMeasurements(float temperature,

float humidity, float pressure) {

notifyObservers methods are this.temperature = temperature;

inherited from the Observable this.humidity = humidity;

class this.pressure = pressure;

measurementsChanged();}

//getter methods

}
Concrete Subject (WeatherData)
Using Java Built-in Observable
import java.util.Observable;

• Then, call the notifyObserver()

public class WeatherData extends Observable {

private float temperature;

private float humidity;

• There are two option to notify private float pressure;

observers

public WeatherData() { }

• as in the example (PULL), public void measurementsChanged() {

details of change will not be setChanged();

notifyObservers();}

sent to the observer

public void setMeasurements(float temperature,

• No arguments sent by the float humidity, float pressure) {

notify method
this.temperature = temperature;

this.humidity = humidity;

this.pressure = pressure;

• notifyObservers(args ..) measurementsChanged();}

(PUSH) //getter methods

}
Concrete Observer (Display)
Using Java Built-in Observer
import java.util.Observable;

import java.util.Observer;

public class CurrentConditionsDisplay implements

Observer, DisplayElement {

Observable observable;

private float temperature;

private float humidity;

• Implement the Observer public CurrentConditionsDisplay(Observable observable) {

this.observable = observable;

interface from java.util

observable.addObserver(this);}

• same as old implementation public void update(Observable obs, Object arg) {

if (obs instanceof WeatherData) {

WeatherData weatherData = (WeatherData) obs;

this.temperature = weatherData.getTemperature();

this.humidity = weatherData.getHumidity();

display();}}

//display method here

}
Concrete Observer (Display)
Using Java Built-in Observer
import java.util.Observable;

import java.util.Observer;

public class CurrentConditionsDisplay implements

Observer, DisplayElement {

• The java.util Observable is

Observable observable;

private float temperature;

passed to the constructor

private float humidity;

public CurrentConditionsDisplay(Observable observable) {

• In the old implementation, we this.observable = observable;

passed the Concrete subject observable.addObserver(this);}

(WeatherData) to the public void update(Observable obs, Object arg) {

constructor

if (obs instanceof WeatherData) {

WeatherData weatherData = (WeatherData) obs;

• why? this.temperature = weatherData.getTemperature();

this.humidity = weatherData.getHumidity();

display();}}

//display method here

}
Concrete Observer (Display)
Using Java Built-in Observer
import java.util.Observable;

import java.util.Observer;

• The update() takes two public class CurrentConditionsDisplay implements

Observer, DisplayElement {

parameters; Observable & and Observable observable;

optional data argument

private float temperature;

private float humidity;

• Make sure that the observable public CurrentConditionsDisplay(Observable observable) {

this.observable = observable;

is of type WeatherData
observable.addObserver(this);}

• Use the getter methods in the public void update(Observable obs, Object arg) {

WeatherData to get the if (obs instanceof WeatherData) {

variables values
WeatherData weatherData = (WeatherData) obs;

this.temperature = weatherData.getTemperature();

this.humidity = weatherData.getHumidity();

• Finally, call display() display();}}

//display method here

}
 Notes on the Java built-in
Observable class
• Defined as a class

• The internal implementation to keep a collection of

observers is different than we did in our own
implementation

• We used ArrayList: this means when we send notification,

the notification will be sent in order

• This is not the case for the built-in Observable

Issues with the Java built-in
Observable class
• It violates the OO design principle of programming to
interfaces not implementations

• Observable is not interface and doesn’t even implement

an interface

• This limits its reuse

• It is a class, the only way to use it is by sub classing it

• This means we can’t easily add behaviors

Issues with the Java built-in
Observable class
protected synchronized void setChanged()
{
changed = true;
• Observable protects its crucial }
methods

• What do you think of this?

• Which principle is violated?

Issues with the Java built-in
Observable class
• Observable protects its crucial
methods
protected synchronized void setChanged()
{
• The only way to use changed = true;
setChanged method is by }
subclassing it

• We can’t make an instance of

the Observable and compose it
with our object, we have to
subclass it

• Violate favor composition over

inheritance