Clean Architecture & Design Patterns in Practice · Lezione

Pattern Command e Iterator

Incapsuli le richieste come oggetti con Command e attraversi le collezioni con Iterator.

Lezione 2 di 411 passaggi

Pattern Command e Iterator è una lezione Clean Architecture & Design Patterns in Practice gratuita su CoddyKit. Questa è la lezione 2 di 4. Puoi leggere la lezione completa qui gratuitamente — poi esercitati direttamente nel browser con un editor di codice integrato e un tutor IA disponibile 24/7. Fa parte del percorso di apprendimento Clean Architecture & Design Patterns in Practice, e i tuoi progressi si sincronizzano tra il web e l'app CoddyKit. Il corso Clean Architecture & Design Patterns in Practice include 4 lezioni in totale.

Parti di questa lezione non sono ancora state tradotte e vengono mostrate in inglese.

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.

Rispondi nella lezione interattiva

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.

Gratis per iniziare

Impara Clean Architecture & Design Patterns in Practice con un tutor IA — gratis

Scrivi ed esegui vero codice nel tuo browser, ricevi aiuto istantaneo da un tutor IA disponibile 24/7, e riprendi da dove hai lasciato sul web o nell'app.

Corsi: 12
Lezioni: 48

Inizia a imparare gratis Visualizza il corso completo

Domande Frequenti

La lezione «Pattern Command e Iterator» è gratuita?

Sì — il testo completo di «Pattern Command e Iterator» è gratuito qui sul web. Per esercitarvi in modo interattivo (un editor di codice integrato e un tutor IA 24/7) e sbloccare il resto del corso Clean Architecture & Design Patterns in Practice, passa a CoddyKit PRO. Il corso Clean Architecture & Design Patterns in Practice include 4 lezioni in totale.

Cosa imparerò in «Pattern Command e Iterator»?

Incapsuli le richieste come oggetti con Command e attraversi le collezioni con Iterator. Eserciti Clean Architecture & Design Patterns in Practice con codice pratico che esegui direttamente nel browser, e un tutor IA 24/7 risponde alle tue domande mentre lavori sulla lezione.

Ho bisogno di esperienza per iniziare Clean Architecture & Design Patterns in Practice?

Non è richiesta alcuna esperienza precedente. Clean Architecture & Design Patterns in Practice su CoddyKit è strutturato per principianti e studenti avanzati, quindi puoi iniziare da qui o dall'inizio e procedere al tuo ritmo. Questa è la lezione 2 di 4.

Quanto tempo richiede la lezione «Pattern Command e Iterator»?

La maggior parte delle lezioni CoddyKit richiede circa 5–10 minuti. Ogni lezione è breve e interattiva, quindi fai progressi costanti e riprendi esattamente da dove hai lasciato su web e app.

Posso scrivere ed eseguire codice in questa lezione Clean Architecture & Design Patterns in Practice?

Sì. Ogni lezione Clean Architecture & Design Patterns in Practice include un editor di codice integrato, quindi scrivi ed esegui codice reale direttamente nel tuo browser e ricevi feedback istantaneo dall'IA — nessuna configurazione locale necessaria.

Tutte le lezioni di questo corso

← Torna a Clean Architecture & Design Patterns in Practice