Clean Architecture & Design Patterns in Practice · Lekcja

Wzorce Command i Iterator

Hermetyzuj żądania jako obiekty za pomocą Command i przechodź po kolekcjach za pomocą Iterator.

Wzorce Command i Iterator to bezpłatna lekcja Clean Architecture & Design Patterns in Practice na CoddyKit. To lekcja 2 z 4. Możesz przeczytać całą lekcję poniżej za darmo — a potem ćwiczyć ją interaktywnie w przeglądarce z wbudowanym edytorem kodu i tutorem AI dostępnym 24/7. To część ścieżki edukacyjnej Clean Architecture & Design Patterns in Practice, a Twój postęp synchronizuje się między webem a aplikacją CoddyKit. Kurs Clean Architecture & Design Patterns in Practice zawiera 4 lekcji w sumie.

Części tej lekcji nie zostały jeszcze przetłumaczone i są wyświetlane po angielsku.

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.

Często zadawane pytania

Czy lekcja „Wzorce Command i Iterator” jest bezpłatna?

Tak — pełny tekst „Wzorce Command i Iterator” jest dostępny za darmo tutaj w sieci. Aby ćwiczyć ją interaktywnie (wbudowany edytor kodu i tutor AI dostępny 24/7) i odblokować resztę kursu Clean Architecture & Design Patterns in Practice, przejdź na CoddyKit PRO. Kurs Clean Architecture & Design Patterns in Practice zawiera 4 lekcji w sumie.

Co nauczysz się w „Wzorce Command i Iterator”?

Hermetyzuj żądania jako obiekty za pomocą Command i przechodź po kolekcjach za pomocą Iterator. Ćwiczysz Clean Architecture & Design Patterns in Practice z praktycznym kodem, który uruchamiasz bezpośrednio w przeglądarce, a tutor AI dostępny 24/7 odpowiada na Twoje pytania podczas pracy nad lekcją.

Czy potrzebuję doświadczenia, aby zacząć Clean Architecture & Design Patterns in Practice?

Nie wymagamy żadnego doświadczenia. Clean Architecture & Design Patterns in Practice w CoddyKit jest strukturyzowany dla początkujących i zaawansowanych użytkowników, więc możesz zacząć tutaj lub od początku i uczyć się w swoim tempie. To lekcja 2 z 4.

Ile czasu zajmuje lekcja „Wzorce Command i Iterator”?

Większość lekcji CoddyKit trwa około 5–10 minut. Każda lekcja to mały, interaktywny krok, dzięki czemu robisz systematyczne postępy i zawsze wracasz dokładnie do tego samego miejsca — na webie i w aplikacji.

Czy mogę pisać i uruchamiać kod w tej lekcji Clean Architecture & Design Patterns in Practice?

Tak. Każda lekcja Clean Architecture & Design Patterns in Practice zawiera wbudowany edytor kodu, więc piszesz i uruchamiasz prawdziwy kod bezpośrednio w przeglądarce i od razu otrzymujesz sprzężenie zwrotne od AI — bez konfiguracji na komputerze.

Wszystkie lekcje w tym kursie

← Powrót do Clean Architecture & Design Patterns in Practice