Clean Architecture & Design Patterns in Practice · Lesson

Command and Iterator Patterns

Encapsulate requests as objects with Command and traverse collections with Iterator.

Command and Iterator Patterns is a free Clean Architecture & Design Patterns in Practice lesson on CoddyKit — lesson 2 of 4. You can read the complete lesson below for free — then practise it hands-on in the browser with a built-in code editor and a 24/7 AI tutor. It is part of the Clean Architecture & Design Patterns in Practice learning path, one of 4 lessons in the course, and your progress syncs across the web and the CoddyKit app.

What is the Command Pattern?

The Command Pattern is a behavioral design pattern that turns a request into a stand-alone object. This object contains all information about the request, including the method to call and the parameters it needs.

Think of it like putting an instruction into a package. You can then pass this package around, queue it, or even undo it later, without the sender needing to know how the instruction is carried out.

Core Components of Command

To understand the Command Pattern, let's look at its key players:

Command: An interface or abstract class declaring an execute() method.
ConcreteCommand: Implements the Command interface, binding a specific Receiver object to an action.
Receiver: The object that performs the actual work. It knows how to carry out the operation.
Invoker: Asks the command to carry out its request. It doesn't know the specifics of the operation or the receiver.
Client: Creates a ConcreteCommand object and sets its Receiver.

Command Pattern in Action

Let's imagine a smart home system where you want to control a light. Without the Command Pattern, your remote control would directly call light.turnOn() or light.turnOff().

With the Command Pattern, the remote control only knows how to 'execute a command'. It doesn't care if it's turning a light on, opening a garage door, or playing music. This makes your remote control (Invoker) very flexible!

Code: Light On/Off Command

Here's a simple Java example demonstrating the Command Pattern for controlling a light. Notice how the RemoteControl (Invoker) only interacts with the Command interface.

interface Command {
  void execute();
}

class Light {
  public void turnOn() {
    System.out.println("Light is ON");
  }
  public void turnOff() {
    System.out.println("Light is OFF");
  }
}

class LightOnCommand implements Command {
  private Light light;

  public LightOnCommand(Light light) {
    this.light = light;
  }

  @Override
  public void execute() {
    light.turnOn();
  }
}

class LightOffCommand implements Command {
  private Light light;

  public LightOffCommand(Light light) {
    this.light = light;
  }

  @Override
  public void execute() {
    light.turnOff();
  }
}

class RemoteControl {
  private Command command;

  public void setCommand(Command command) {
    this.command = command;
  }

  public void pressButton() {
    command.execute();
  }
}

public class Main {
  public static void main(String[] args) {
    Light livingRoomLight = new Light();

    LightOnCommand onCommand = new LightOnCommand(livingRoomLight);
    LightOffCommand offCommand = new LightOffCommand(livingRoomLight);

    RemoteControl remote = new RemoteControl();

    remote.setCommand(onCommand);
    remote.pressButton();

    remote.setCommand(offCommand);
    remote.pressButton();
  }
}

Benefits of Command Pattern

The Command Pattern offers several powerful advantages:

Decoupling: The invoker is decoupled from the receiver, reducing dependencies.
Undo/Redo: Commands can be stored in a history list, making undo/redo functionality easier to implement.
Queuing/Logging: Requests can be queued, logged, and executed at different times.
Extensibility: Adding new commands doesn't require changing existing invoker code.

What is the Iterator Pattern?

The Iterator Pattern is a behavioral design pattern that provides a way to access the elements of an aggregate object (like a list or array) sequentially without exposing its underlying representation.

Imagine you have a playlist of songs. An iterator allows you to go through each song one by one (next, previous, etc.) without needing to know if the playlist is stored as an array, a linked list, or something else entirely.

Core Components of Iterator

The Iterator Pattern involves these main components:

Iterator: An interface defining methods for accessing and traversing elements (e.g., hasNext(), next()).
ConcreteIterator: Implements the Iterator interface, keeping track of the current position in the traversal.
Aggregate: An interface or abstract class defining a method for creating an Iterator object (e.g., createIterator()).
ConcreteAggregate: Implements the Aggregate interface and returns an instance of a ConcreteIterator.

Iterator Pattern in Action

Most programming languages have built-in iterators (like Java's Iterator or Python's iterables). But sometimes, you build a custom collection where you need to define your own traversal logic.

For example, if you have a custom MyStringList class that stores strings internally, an iterator would allow external code to loop through these strings without knowing if MyStringList uses an array, a linked list, or a tree structure internally.

Code: Custom List Iterator

This Java example shows how to create a custom StringList and an Iterator for it. The Main method can iterate through the list using the iterator without knowing its internal array.

interface MyIterator {
  boolean hasNext();
  String next();
}

interface MyAggregate {
  MyIterator createIterator();
}

class MyStringList implements MyAggregate {
  private String[] items;
  private int count;

  public MyStringList(int capacity) {
    items = new String[capacity];
    count = 0;
  }

  public void add(String item) {
    if (count < items.length) {
      items[count++] = item;
    }
  }

  @Override
  public MyIterator createIterator() {
    return new StringListIterator(this);
  }

  // Helper to access elements by index for the iterator
  public String get(int index) {
    if (index >= 0 && index < count) {
      return items[index];
    }
    return null;
  }

  public int size() {
    return count;
  }
}

class StringListIterator implements MyIterator {
  private MyStringList list;
  private int position;

  public StringListIterator(MyStringList list) {
    this.list = list;
    this.position = 0;
  }

  @Override
  public boolean hasNext() {
    return position < list.size();
  }

  @Override
  public String next() {
    if (hasNext()) {
      return list.get(position++);
    }
    return null;
  }
}

public class Main {
  public static void main(String[] args) {
    MyStringList names = new MyStringList(5);
    names.add("Alice");
    names.add("Bob");
    names.add("Charlie");

    MyIterator iterator = names.createIterator();

    System.out.println("Iterating through names:");
    while (iterator.hasNext()) {
      System.out.println(iterator.next());
    }
  }
}

Quick Check: Design Patterns

You've learned about two powerful behavioral patterns. Let's test your understanding.

Recap: Command & Iterator

Great job! In this lesson, we explored two essential behavioral design patterns:

The Command Pattern encapsulates a request as an object, enabling powerful features like undo/redo, queuing, and logging requests, while decoupling the invoker from the receiver.
The Iterator Pattern provides a standardized way to traverse elements in a collection, abstracting away the collection's internal structure and promoting flexible iteration methods.

Mastering these patterns will significantly improve the flexibility and maintainability of your software designs.

Frequently asked questions

Is the “Command and Iterator Patterns” lesson free?

Yes — the full text of “Command and Iterator Patterns” is free to read here on the web, and the Clean Architecture & Design Patterns in Practice course includes 4 lessons in total. To practise it interactively (a built-in code editor and a 24/7 AI tutor) and unlock the rest of the Clean Architecture & Design Patterns in Practice course, upgrade to CoddyKit PRO.

What will I learn in “Command and Iterator Patterns”?

Encapsulate requests as objects with Command and traverse collections with Iterator. You practise Clean Architecture & Design Patterns in Practice with hands-on code you run directly in the browser, and a 24/7 AI tutor answers your questions as you work through the lesson.

Do I need any experience to start Clean Architecture & Design Patterns in Practice?

No prior experience is required. Clean Architecture & Design Patterns in Practice on CoddyKit is structured for beginners through advanced learners; this is — lesson 2 of 4, so you can start here or from the beginning and move at your own pace.

How long does the “Command and Iterator Patterns” lesson take?

Most CoddyKit lessons take about 5–10 minutes. Each one is bite-sized and interactive, so you make steady progress and pick up exactly where you left off across the web and the app.

Can I write and run code in this Clean Architecture & Design Patterns in Practice lesson?

Yes. Every Clean Architecture & Design Patterns in Practice lesson includes a built-in code editor, so you write and run real code right in your browser and get instant AI feedback — no local setup required.

All lessons in this course

← Back to Clean Architecture & Design Patterns in Practice