Iterator & Observer

The rest of the family (named, not covered)

The lecture lists these so you recognise them as behavioral if they appear in a question: Command, Chain of Responsibility, Interpreter, Mediator, Memento, State, Strategy, Template Method and Visitor. Only Iterator and Observer are examinable in detail here.

The two words that matter

• Sequentially — one element after another, in a defined order.
• Without knowing the representation — the client never learns whether it is walking an array, a linked list, or a tree. Change the storage, and no client breaks.

Structure — who refers to whom

Worked Example — a name collection

Setup: a NameRepository stores names in a plain array, but the client should be able to walk it without knowing that. The concrete class implements Container and holds an inner class NameIterator that implements Iterator.

// The Iterator interface — the traversal contract
public interface Iterator {
  public boolean hasNext();
  public Object next();
}

// The Aggregate / Container interface — the "give me an iterator" contract
public interface Container {
  public Iterator getIterator();
}

// Concrete collection + its concrete iterator as an inner class
public class NameRepository implements Container {
  public String[] names = {"Robert", "John", "Julie", "Lora"};

  public Iterator getIterator() { return new NameIterator(); }

  private class NameIterator implements Iterator {
    int index; // the iterator holds the position, NOT the collection

    public boolean hasNext() { return index < names.length; }

    public Object next() {
      if (this.hasNext()) return names[index++];
      return null;
    }
  }
}

// Client — knows Container and Iterator, knows nothing about the array
NameRepository namesRepository = new NameRepository();
for (Iterator iter = namesRepository.getIterator(); iter.hasNext(); ) {
  String name = (String) iter.next();
  System.out.println("Name : " + name);
}
// → Name : Robert / Name : John / Name : Julie / Name : Lora

Step-by-step: how to design one

1. Identify and design the Iterator interface.
2. For each class representing a collection data structure, design a concrete Iterator and associate it with that collection. Implement the concrete iterator's methods in terms of that data structure.
3. Create the Collection interface, which includes the interface method that creates Iterators.
4. For each collection class, implement the Aggregate interface to instantiate and return a concrete Iterator.

The three words that matter

• One-to-many — one Subject, many Observers.
• Dependency — observers care about the subject's state; the subject does not care what they do with it.
• Automatically — nobody polls. The subject pushes the notification the moment state changes.

Structure

Worked Example — one integer, three displays

Setup: a Subject holds a single state integer. Three observers — BinaryObserver, OctalObserver and HexaObserver — each render that same number in their own base. Set the state once, and all three print.

// The Subject — keeps the list, owns the notification
public class Subject {
  private List<Observer> observers = new ArrayList<>();
  private int state;

  public int getState() { return state; }

  public void setState(int state) {
    this.state = state;
    notifyAllObservers(); // state changed → tell everyone, automatically
  }

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

  public void notifyAllObservers() {
    for (Observer observer : observers) observer.update(); // iterate + update
  }
}

// The Observer abstraction — one abstract update() method
public abstract class Observer {
  protected Subject subject;
  public abstract void update();
}

// A concrete observer — registers itself with the subject in its constructor
public class BinaryObserver extends Observer {
  public BinaryObserver(Subject subject) {
    this.subject = subject;
    this.subject.attach(this); // attach at construction time
  }
  public void update() {
    System.out.println("Binary String: " + Integer.toBinaryString(subject.getState()));
  }
}
// OctalObserver and HexaObserver are identical apart from the conversion call.

// Client — attach once, then just change the state
Subject subject = new Subject();
new HexaObserver(subject);
new OctalObserver(subject);
new BinaryObserver(subject);

subject.setState(15); // → Hex: F · Octal: 17 · Binary: 1111
subject.setState(10); // → Hex: A · Octal: 12 · Binary: 1010

Step-by-step: how to apply it

1. Design the Subject interface and implement the code for attaching, detaching and notifying observer objects. Keeping track of observers can be done with an existing linked-list data structure.
2. For classes that manage information of interest to observers, inherit from the Subject class created in step 1.
3. Design the Observer interface, which includes the abstract update() interface method.
4. For all observers in the system, implement the Observer interface — which requires implementing update().
5. At run time, create each observer and attach it to the subject. When changes occur, the subject iterates through its list of registered objects and calls their update() method.

Where they meet

Look again at notifyAllObservers(): the Subject iterates over its observer list to notify it. Observer uses iteration internally — which is why these two land in the same lecture and why an exam question can legitimately involve both at once.

Distinguishing them from the structural three