java observer pattern

A good example to picture observer pattern is a newspaper subscription service with its publisher and subscribers. The observer pattern defines a one-to-many relationship between a set of objects. When the state of one object changes, all of its dependents are notified. A visualized example of observer pattern is below.

I prepared a little example code of java observer pattern(*). The example acts like a tracker agent that it follows price and stock changes of a product. When price/stock information changes, all observers are updated new price/stock information.

The code includes three interfaces. “Subject” interface which is subscription service. The others are “Observer” and “DisplayProduct”.


public interface Subject {
public void registerObserver(Observer observer);
public void removeObserver(Observer observer);
/**
* Notify all observers when the Subject's state has changed.
*/
public void notifyObservers();
}

/**
* The Observer interface is implemented by all observers,
* all observers have to implement the update() method.
*/
public interface Observer {
public void update(float price, boolean stock);
}

/**
* It will be called when display product needs to be displayed.
*/
public interface DisplayProduct() {
public void display();
}

The code includes three classes. “Tracker” implements Subject interface that Tracker object is our subject object as above picture.


public class Tracker implements Subject {
private ArrayList observers;
private int price;
private boolean stock;

public Tracker() {
observers = new ArrayList();
}

public void registerObserver(Observer observer) {
observers.add(observer);
}

public void removeObserver(Observer observer) {
int index = observers.indexOf(o);
if (index >= 0) {
observers.remove(index);
}
}

public void notifyObservers() {
for (int i=0; i < observers.size(); i++) {
Observer observer = (Observer)observers.get(i);
observer.update(price,stock);
}
}

public void stockPriceChanged() {
notifyObservers();
}

public void setStockPrice(float mPrice, boolean mStock) {
this.price = mPrice;
this.stock = mStock;
stockPriceChanged();
}
}

One of the other classes is “FollowedProductDisplay” which is implements both of Observer and DisplayProduct interfaces. FollowedProductDisplay objects are our observers.


public class FollowedProductDisplay implements Observer, DisplayProduct {
private float price;
private boolean stock;
private Subject tracker;

public FollowedProductDisplay(Subject mTracker) {
this.tracker = mTracker;
tracker.registerObserver(this);
}

public void update(float mPrice, boolean mStock) {
this.price = mPrice;
this.stock = mStock;
display();
}

public void display() {
System.out.println("Followed product: price -> "
+ price + " stock -> " + stock);
}
}

The last class is “TrackerAgent” that it contains our subject and observer objects.


public class TrackerAgent {
public static void main(String[] args) {
Tracker tracker = new Tracker();
FollowedProductDisplay followedProduct =
new FollowedProductDisplay(tracker);
tracker.setStockPrice(124.50,true);
tracker.setStockPrice(114.50,true);
}
}

The result of the example is below:


Followed product: price -> 124.50 stock -> true
Followed product: price -> 114.50 stock -> true

(*) I get remarkable help from the book. Head First Design Patterns, Eric Freeman, Elisabeth Robson, Bert Bates, Kathy Sierra, O’Reilly Media, 2004.