The Observable interface

The java.util.Observable interface implements the Observer pattern, which can be co-related here. However, all similarities end here. If we look at the Observable interface, we have the following methods:

public class Observable {
  void addObserver (Observer o);
  void deleteObserver (Observer o);
  void deleteObservers();
  void notifyObservers();
  void notifyObserver(int arg);
  int countObservers();
  boolean hasChanged();
}

Let's look at the Observer interface before we determine the differences:

public interface Observer{
  void update(Observable o, Object arg)
}

If we look at the Observable and Observer interfaces, we can see that they are all about a single event and its state. The Observable API has the responsibility of determining a change and publishing it to all interested parties. On the other hand, the Observer only listens to the change. This is not what we are modeling with the Publisher and Subscriber interface. The Publisher interface is responsible for generating unbounded events, unlike the Observable, which is all about single entity state changes. The Subscriber, on the other hand, lists all kinds of events, such as data, error, and completion.

Furthermore, the Observable maintains an active list of observers. It has the responsibility of removing observers that are no longer interested in the event. This is not the same as the Publisher, which is only responsible for subscriptions. The Subscriber makes the decision to close the subscription, at its will.