SE322 · Chapter 7 · Lecture 2 · Annotated SlidesBehavioral Design Patterns: Iterator and Observer
PDF
Overview

Behavioral Design Patterns: Iterator and Observer

Behavioural patterns distribute behaviour among objects efficiently and safely. Iterator gives clients a standard way (hasNext(), next()) to walk through a collection without knowing whether it is an array, a list or a tree: the collection hands out an iterator that keeps its own position. Observer sets up a one-to-many dependency: observers attach to a subject, and when the subject’s state changes it calls update() on every registered observer, so they stay in sync without the subject knowing their concrete classes.

Iterator roles

Iterator interface (hasNext, next), ConcreteIterator (keeps the index), Aggregate/Container (getIterator), ConcreteAggregate.

Iterator benefits

Consistent traversal; collection internals can change without changing clients; several traversals (forward, reverse) over the same data.

Observer roles

Subject (attach, detach, notify, holds state and an observer list), Observer (update), ConcreteObservers.

Observer flow

setState() → notifyAllObservers() → each observer.update() → observer reads subject.getState().

How the lecture is organized

Exam focus

Final 252 Q7-2 (2.5 marks) asked you to recognise Observer in a weather-station scenario and draw its class diagram. Iterator has not been examined yet; expect it as a “which pattern?” question.

How to read this page

Every original slide is shown unchanged. Yellow marks on a slide point to a numbered note: hover or tap a mark to jump to its note, and hover a note to see its marks. Questions tagged Past exam appeared on a real paper; Prediction questions are likely angles, not confirmed.

All 32 slides
  1. 1 Slide 1
  2. 2 Lecture Outlines
  3. 3 Behavioral Design Patterns
  4. 4 1- Iterator Design Pattern
  5. 5 Iterator: class and sequence diagrams
  6. 6 Iterator: generic structure
  7. 7 Iterator Design Pattern –
  8. 8 Iterator Example: Iterator.java and Container.java
  9. 9 Iterator Design Pattern –
  10. 10 Iterator Example: NameRepository.java
  11. 11 Iterator Example: the code together
  12. 12 Iterator Design Pattern –
  13. 13 Iterator Example: the client and output
  14. 14 Iterator Design Pattern
  15. 15 Iterator Design Pattern
  16. 16 In class exercise: the company directory
  17. 17 Observer Design Pattern
  18. 18 Observer Design Pattern - Structure
  19. 19 Observer Design Pattern – Example: class diagram
  20. 20 Observer Example: Subject.java
  21. 21 Observer Example: the Observer class
  22. 22 Observer Example: Observer.java
  23. 23 Observer Example: concrete observers
  24. 24 Observer Example: BinaryObserver.java
  25. 25 Observer Example: OctalObserver.java
  26. 26 Observer Example: HexaObserver.java
  27. 27 Observer Example: the client
  28. 28 Observer Example: ObserverPatternDemo.java
  29. 29 Observer Design Pattern
  30. 30 Observer Design Pattern
  31. 31 In class activity: social-media followers
  32. 32 Summary
Slide 1 / 32

Slide 1

Slide 1: Slide 1

Notes

  1. The last design-pattern lecture: behavioural patterns, which are about how objects interact and share work. Two are covered: Iterator and Observer.

Slide 2 / 32

Lecture Outlines

Slide 2: Lecture Outlines

Notes

  1. Previously: the structural patterns Adapter, Composite and Facade.

  2. Today: Iterator and Observer.

Slide 3 / 32

Behavioral Design Patterns

Slide 3: Behavioral Design Patterns

Notes

  1. Behavioural patterns are responsible for the efficient and safe distribution of behaviours among a program’s objects: who does what, and how they communicate.

  2. This course covers Iterator and Observer.

  3. Others exist but are not covered: Command, Chain of Responsibility, Interpreter, Mediator, Memento, State, Strategy, Template Method, Visitor.

Slide 4 / 32

1- Iterator Design Pattern

Slide 4: 1- Iterator Design Pattern

Notes

  1. Iterator is an object behavioural pattern that gives a standard way of accessing and traversing the objects in a collection.

  2. Its intent: provide a way to access the elements of a collection sequentially without knowing its underlying representation. The client asks “is there another one?” and “give me the next one”, and never sees whether the data is an array, a linked list or a tree.

Exam angle

PredictionQ1

Traversing a collection without exposing whether it is stored as an array, a list or a tree is the:

  1. Iterator pattern
  2. Observer pattern
  3. Composite pattern
  4. Facade pattern
Show answer

A. Iterator pattern

Slide 5 / 32

Iterator: class and sequence diagrams

Slide 5: Iterator: class and sequence diagrams

Notes

  1. In the class diagram (left), the Client refers (1) to the Aggregate interface to create an iterator with createIterator()…

  2. …and (2) to the Iterator interface to traverse the aggregate with next() and hasNext().

  3. Iterator1 implements Iterator by accessing Aggregate1, which creates it. The sequence diagram (right) shows the run: the client calls createIterator(), Aggregate1 creates an Iterator1 and returns it, then the client loops [while hasNext()] next() and gets one element each time.

Slide 6 / 32

Iterator: generic structure

Slide 6: Iterator: generic structure

Notes

  1. The generic structure: an Aggregate with iterator() and an Iterator with next() and hasNext() (italic = abstract), linked by «create».

  2. ConcreteAggregate implements iterator() to create a ConcreteIterator, which implements next() and hasNext() and keeps a reference to its aggregate (the diamond) so it can read the elements.

Slide 7 / 32

Iterator Design Pattern –

Slide 7: Iterator Design Pattern –

Notes

  1. The example’s structure: «Interface» Container (getIterator(): Iterator) plays the aggregate; «Interface» Iterator has hasNext(): boolean and next(): Object.

  2. NameRepository implements Container and holds -name : String[]; it “has” a NameIterator, which implements Iterator.

  3. The client IteratorPatternDemo uses NameRepository through the interfaces.

Slide 8 / 32

Iterator Example: Iterator.java and Container.java

Slide 8: Iterator Example: Iterator.java and Container.java

Notes

  1. The two interfaces:

    CodeWhat it does
    public interface Iterator { public boolean hasNext(); public Object next(); }The traversal contract: is there another element, and give me it.
    public interface Container { public Iterator getIterator(); }The aggregate contract: hand out an iterator.
Slide 9 / 32

Iterator Design Pattern –

Slide 9: Iterator Design Pattern –

Notes

  1. The diagram with the two concrete classes outlined: NameRepository (the concrete collection) and NameIterator (the concrete iterator). They are written next.

Slide 10 / 32

Iterator Example: NameRepository.java

Slide 10: Iterator Example: NameRepository.java

Notes

  1. Create a concrete class implementing the Container interface.

  2. It has an inner class NameIterator implementing Iterator:

    CodeWhat it does
    public class NameRepository implements Container { public String names[] = {"Robert", "John", "Julie", "Lora"};The data, stored as an array.
    @Override public Iterator getIterator() { return new NameIterator(); }Hands out a fresh iterator each time.
    private class NameIterator implements Iterator { int index;An inner class, so it can read names directly; index is its own cursor.
    public boolean hasNext() { if (index < names.length) { return true; } return false; }Another element exists while the cursor is inside the array.
    public Object next() { if (this.hasNext()) { return names[index++]; } return null; } } }Return the current name and advance; null past the end.
Slide 11 / 32

Iterator Example: the code together

Slide 11: Iterator Example: the code together

Notes

  1. All the code on one slide: the interfaces on the left and NameRepository with its inner NameIterator on the right. The client only ever sees Container and Iterator, so the names could move into a list or a database without changing it.

Slide 12 / 32

Iterator Design Pattern –

Slide 12: Iterator Design Pattern –

Notes

  1. The diagram with the client IteratorPatternDemo outlined: next, the code that uses the repository.

Slide 13 / 32

Iterator Example: the client and output

Slide 13: Iterator Example: the client and output

Notes

  1. The client:

    CodeWhat it does
    NameRepository namesRepository = new NameRepository();The collection.
    for (Iterator iter = namesRepository.getIterator(); iter.hasNext();) {Get an iterator and loop while there is a next element.
    String name = (String) iter.next(); System.out.println("Name : " + name); }Read and print each one.

  2. Output: “Name : Robert”, “Name : John”, “Name : Julie”, “Name : Lora”.

Slide 14 / 32

Iterator Design Pattern

Slide 14: Iterator Design Pattern

Notes

  1. 1. Design the Iterator interface.

  2. 2. For each collection class, design a concrete iterator and associate it with the collection; implement its methods in terms of that data structure.

  3. 3. Create the collection (aggregate) interface with a method that creates iterators.

  4. 4. For each collection class, implement that interface so it instantiates and returns its concrete iterator.

Slide 15 / 32

Iterator Design Pattern

Slide 15: Iterator Design Pattern

Notes

  1. A consistent way for clients to iterate through any collection.

  2. It abstracts the internals of the collection, so if they change, clients don’t.

  3. Client code is easy to extend: many iterators can support different traversals (forward, reverse, filtered) over the same or different collections.

Exam angle

PredictionQ1

Give two benefits of the Iterator pattern.

Show answer

Clients traverse every collection the same way (hasNext/next); the collection’s internal representation is hidden, so it can change without affecting clients; several iterators can provide different traversals (e.g. forward and reverse) of the same collection.

Slide 16 / 32

In class exercise: the company directory

Slide 16: In class exercise: the company directory

Notes

  1. The exercise: a company directory stores employee records in two different internal data structures (an array and a list) but lets clients traverse both the same way.

  2. The client also needs two traversals: standard and reverse.

  3. Answer: Iterator. A DirectoryIterator interface (hasNext(), next()); ArrayDirectory and ListDirectory each implement a Directory interface with createIterator() and createReverseIterator(), returning concrete iterators that know their structure. The client loops with hasNext()/next() whichever directory and direction it uses.

Exam angle

PredictionQ1

A company directory stores employees in an array in one version and a linked list in another, and clients need forward and reverse traversal of both. Which pattern, and what classes?

Show answer

Iterator. An EmployeeIterator interface (hasNext(), next()); a Directory interface with createIterator() and createReverseIterator(); ArrayDirectory and ListDirectory implement Directory and return ArrayForwardIterator/ArrayReverseIterator and ListForwardIterator/ListReverseIterator. The client uses only Directory and EmployeeIterator.

Slide 17 / 32

Observer Design Pattern

Slide 17: Observer Design Pattern

Notes

  1. Observer is an object behavioural pattern that standardises how objects in a one-to-many relationship work together.

  2. Its intent: define a one-to-many dependency so that when one object changes state, all its dependents are notified and updated automatically. Like a newsletter: subscribe once, and every new issue is pushed to you.

Exam angle

Past exam · Final 252 · Q7-2 · 2.5 marksQ1

Global Weather Sync: when the primary weather station’s temperature changes, all registered city dashboards update instantly, in Celsius and Fahrenheit. Which pattern? Draw its class diagram.

Show answer

Pattern: Observer. A one-to-many dependency: when the subject changes, all observers are notified automatically. Subject (interface): attach(), detach(), notifyObservers(). WeatherStation (concrete subject): holds the temperature and a list of observers; setTemperature() stores the value and calls notifyObservers(). Observer (interface): update(temp). CelsiusDashboard and FahrenheitDashboard (concrete observers) show the temperature in their own unit (Fahrenheit = t × 9/5 + 32). Diagram: WeatherStation realizes Subject; the dashboards realize Observer; Subject keeps a list of Observers.

Slide 18 / 32

Observer Design Pattern - Structure

Slide 18: Observer Design Pattern - Structure

Notes

  1. Subject: attach(in Observer) to register observers, setState() to change, getState() to read. It keeps its observers (the “views”, multiplicity \*).

  2. «interface» Observer: update(). Each observer holds a reference back to its subject (the “model” arrow) so it can read the new state.

  3. ViewOne and ViewTwo realise Observer, each with its own update(). This is the same mechanism MVC uses to refresh views when the model changes.

Exam angle

PredictionQ1

In the Observer pattern, what happens when the subject’s state changes?

Show answer

The subject calls its notify method, which loops over every registered observer and calls update() on each; each observer then reads the new state (e.g. via subject.getState()) and refreshes itself.

Slide 19 / 32

Observer Design Pattern – Example: class diagram

Slide 19: Observer Design Pattern – Example: class diagram

Notes

  1. The example: a Subject with -observers: List<Observer> and -state: int, and the operations getState(), setState(), attach() and notifyAllObservers().

  2. «abstract» Observer has +subject: Subject and +update(); BinaryObserver, OctalObserver and HexaObserver extend it.

  3. ObserverPatternDemo is the client. Whenever the number changes, each observer prints it in its own base.

Slide 20 / 32

Observer Example: Subject.java

Slide 20: Observer Example: Subject.java

Notes

  1. Subject.java:

    CodeWhat it does
    private List<Observer> observers = new ArrayList<Observer>(); private int state;The registered observers and the state they care about.
    public int getState() { return state; }Observers read the state through this.
    public void setState(int state) { this.state = state; notifyAllObservers(); }Changing the state triggers notification: the heart of the pattern.
    public void attach(Observer observer) { observers.add(observer); }Registration.
    public void notifyAllObservers() { for (Observer observer : observers) { observer.update(); } }Tell every observer, without knowing their concrete classes.
Slide 21 / 32

Observer Example: the Observer class

Slide 21: Observer Example: the Observer class

Notes

  1. The diagram with the abstract Observer outlined: it holds +subject: Subject and declares +update().

Slide 22 / 32

Observer Example: Observer.java

Slide 22: Observer Example: Observer.java

Notes

  1. Observer.java:

    CodeWhat it does
    public abstract class Observer { protected Subject subject;An abstract class here (an interface works too); every observer knows its subject.
    public abstract void update(); }Called by the subject on every change.
Slide 23 / 32

Observer Example: concrete observers

Slide 23: Observer Example: concrete observers

Notes

  1. The diagram with the three concrete observers outlined: BinaryObserver, OctalObserver and HexaObserver, each implementing update() its own way.

Slide 24 / 32

Observer Example: BinaryObserver.java

Slide 24: Observer Example: BinaryObserver.java

Notes

  1. BinaryObserver.java:

    CodeWhat it does
    public BinaryObserver(Subject subject) { this.subject = subject; this.subject.attach(this); }The observer registers itself with the subject when created.
    @Override public void update() { System.out.println("Binary String: " + Integer.toBinaryString(subject.getState())); }On notification it pulls the new state and prints it in binary.
Slide 25 / 32

Observer Example: OctalObserver.java

Slide 25: Observer Example: OctalObserver.java

Notes

  1. OctalObserver is identical except that update() prints Integer.toOctalString(subject.getState()).

Slide 26 / 32

Observer Example: HexaObserver.java

Slide 26: Observer Example: HexaObserver.java

Notes

  1. HexaObserver prints Integer.toHexString(subject.getState()).toUpperCase(). Adding a fourth observer (say, Roman numerals) would need no change to Subject.

Slide 27 / 32

Observer Example: the client

Slide 27: Observer Example: the client

Notes

  1. The diagram with the client ObserverPatternDemo outlined: it creates the subject and the observers, then changes the state.

Slide 28 / 32

Observer Example: ObserverPatternDemo.java

Slide 28: Observer Example: ObserverPatternDemo.java

Notes

  1. The client:

    CodeWhat it does
    Subject subject = new Subject();One subject.
    new HexaObserver(subject); new OctalObserver(subject); new BinaryObserver(subject);Three observers; each attaches itself in its constructor.
    System.out.println("First state change: 15"); subject.setState(15);One state change…
    System.out.println("Second state change: 10"); subject.setState(10);…and another.

  2. Output: for 15, “Hex String: F”, “Octal String: 17”, “Binary String: 1111”; for 10, “A”, “12”, “1010”. Each setState call reached all three observers automatically, in the order they attached.

Slide 29 / 32

Observer Design Pattern

Slide 29: Observer Design Pattern

Notes

  1. 1. Design the Subject with code to attach, detach and notify observers (a linked list can keep track of them).

  2. 2. Classes that hold information observers care about inherit from that subject class.

  3. 3. Design the Observer interface with the abstract update() method.

  4. 4. Every observer implements Observer, i.e. its own update().

  5. 5. At run time, create the observers and attach them to the subject; on each change the subject iterates through its list and calls update() on each.

Exam angle

PredictionQ1

True or false: in the Observer pattern the subject must know the concrete classes of its observers.

Show answer

False — It knows them only through the Observer interface, which is what keeps them loosely coupled and lets new observers be added freely.

Slide 30 / 32

Observer Design Pattern

Slide 30: Observer Design Pattern

Notes

  1. Flexibility to add new services: a new observer is just a new class that attaches itself.

  2. Specific services are compartmentalised (each observer handles its own reaction), so maintaining and modifying them is easier. (Watch for: notification order, slow observers holding up the rest, and observers that are never detached.)

Exam angle

PredictionQ1

Give one benefit and one drawback of the Observer pattern.

Show answer

Benefit: new observers (services) can be added without changing the subject; each reaction is isolated in its own class. Drawback: the order of notifications isn’t controlled, every change notifies every observer (cost), and forgotten observers can leak memory or react unexpectedly.

Slide 31 / 32

In class activity: social-media followers

Slide 31: In class activity: social-media followers

Notes

  1. The exercise: a simplified Instagram/X follower system.

  2. Subject = the influencer, who posts status updates and doesn’t want to message every follower by hand.

  3. Observers = the followers, who want to be notified the moment a post goes live.

  4. The tasks, as code:

    CodeWhat it does
    interface Follower { void update(String post); }The observer interface.
    class Influencer { List<Follower> followers = new ArrayList<>(); void follow(Follower f) { followers.add(f); } void unfollow(Follower f) { followers.remove(f); }The subject keeps its followers…
    void post(String text) { notifyFollowers(text); } void notifyFollowers(String p) { for (Follower f : followers) f.update(p); } }…and notifies all of them on each post.
    class MobileAppUser implements Follower { public void update(String post) { System.out.println("Mobile User received notification: " + post); } }Concrete observers (WebBrowserUser is the same with “Web User”).
Slide 32 / 32

Summary

Slide 32: Summary

Notes

  1. Behavioural patterns covered: Iterator (hide how a collection is traversed) and Observer (broadcast state changes to registered objects).

  2. Next: architecture evaluation (Chapter 8).