Clean Architecture en ontwerppatronen in de praktijk · Les

Command- en Iterator-patronen

Encapsuleer verzoeken als objecten met Command en doorloop collecties met Iterator.

Les 2 van 411 stappen

Command- en Iterator-patronen is een gratis Clean Architecture en ontwerppatronen in de praktijk-les op CoddyKit. Dit is les 2 van 4. Je kunt de volledige les hieronder gratis lezen en daarna in de browser praktisch oefenen met een ingebouwde code-editor en een AI-begeleider die 24/7 beschikbaar is. Deze les maakt deel uit van het leertraject Clean Architecture en ontwerppatronen in de praktijk. Je voortgang wordt gesynchroniseerd op het web en in de CoddyKit-app. De cursus Clean Architecture en ontwerppatronen in de praktijk bevat in totaal 4 lessen.

Wat is het Command-patroon?

Het Command-patroon is een gedragsontwerppatroon dat een verzoek omzet in een zelfstandig object. Dit object bevat alle informatie over het verzoek, waaronder de aan te roepen methode en de parameters die daarvoor nodig zijn.

Je kunt het vergelijken met het verpakken van een instructie. Daarna kun je dit pakket doorgeven, in een wachtrij plaatsen of later zelfs ongedaan maken, zonder dat de verzender hoeft te weten hoe de instructie wordt uitgevoerd.

Basisonderdelen van Command

Om het Command-patroon te begrijpen, bekijken we de belangrijkste onderdelen:

Command: Een interface of abstracte klasse die een execute()-methode declareert.
ConcreteCommand: Implementeert de Command-interface en koppelt een specifiek Receiver-object aan een actie.
Receiver: Het object dat het daadwerkelijke werk uitvoert. Het weet hoe de bewerking moet worden uitgevoerd.
Invoker: Vraagt de opdracht om het verzoek uit te voeren. De invoker kent de details van de bewerking of de ontvanger niet.
Client: Maakt een ConcreteCommand-object en stelt zijn Receiver in.

Command-patroon in actie

Stel je een slimwoningsysteem voor waarmee je een lamp wilt bedienen. Zonder het Command-patroon zou je afstandsbediening rechtstreeks light.turnOn() of light.turnOff() aanroepen.

Met het Command-patroon weet de afstandsbediening alleen hoe hij 'een opdracht moet uitvoeren'. Het maakt niet uit of hij een lamp inschakelt, een garagedeur opent of muziek afspeelt. Daardoor is je afstandsbediening (de Invoker) zeer flexibel.

Code: opdracht voor lamp aan/uit

Hier is een eenvoudig Java-voorbeeld dat het Command-patroon gebruikt om een lamp te bedienen. Let erop dat de RemoteControl (Invoker) alleen communiceert met de 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();
  }
}

Voordelen van het Command-patroon

Het Command-patroon biedt verschillende krachtige voordelen:

Ontkoppeling: De invoker is ontkoppeld van de ontvanger, waardoor het aantal afhankelijkheden afneemt.
Ongedaan maken/opnieuw uitvoeren: Opdrachten kunnen in een geschiedenislijst worden opgeslagen, waardoor functionaliteit voor ongedaan maken en opnieuw uitvoeren eenvoudiger te implementeren is.
In wachtrij plaatsen/loggen: Verzoeken kunnen in een wachtrij worden geplaatst, vastgelegd en op verschillende momenten worden uitgevoerd.
Uitbreidbaarheid: Voor het toevoegen van nieuwe opdrachten hoef je de bestaande code van de invoker niet te wijzigen.

Wat is het Iterator-patroon?

Het Iterator-patroon is een gedragsontwerppatroon dat een manier biedt om opeenvolgend toegang te krijgen tot de elementen van een samengesteld object, zoals een lijst of array, zonder de onderliggende representatie bloot te leggen.

Stel je een afspeellijst met nummers voor. Met een iterator kun je elk nummer één voor één doorlopen (volgende, vorige enzovoort), zonder te hoeven weten of de afspeellijst is opgeslagen als een array, gekoppelde lijst of iets anders.

Basisonderdelen van Iterator

Het Iterator-patroon bestaat uit deze belangrijkste onderdelen:

Iterator: Een interface die methoden definieert voor het openen en doorlopen van elementen (bijvoorbeeld hasNext(), next()).
ConcreteIterator: Implementeert de Iterator-interface en houdt de huidige positie tijdens het doorlopen bij.
Aggregate: Een interface of abstracte klasse die een methode definieert voor het maken van een Iterator-object (bijvoorbeeld createIterator()).
ConcreteAggregate: Implementeert de Aggregate-interface en retourneert een exemplaar van een ConcreteIterator.

Iterator-patroon in actie

De meeste programmeertalen hebben ingebouwde iterators, zoals Java's Iterator of de itereerbare objecten van Python. Soms bouw je echter een aangepaste verzameling waarvoor je je eigen doorlooplogica moet definiëren.

Als je bijvoorbeeld een aangepaste klasse MyStringList hebt die intern tekenreeksen opslaat, maakt een iterator het voor externe code mogelijk deze tekenreeksen te doorlopen zonder te weten of MyStringList intern een array, gekoppelde lijst of boomstructuur gebruikt.

Code: iterator voor aangepaste lijst

Dit Java-voorbeeld laat zien hoe je een aangepaste StringList en een Iterator daarvoor maakt. De Main-methode kan de lijst met de iterator doorlopen zonder de interne array te kennen.

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());
    }
  }
}

Korte controle: ontwerppatronen

Je hebt twee krachtige gedragspatronen geleerd. Laten we je begrip testen.

Beantwoord dit in de interactieve les

Samenvatting: Command en Iterator

Goed gedaan! In deze les hebben we twee essentiële gedragsontwerppatronen verkend:

Het Command-patroon kapselt een verzoek in als een object. Daardoor zijn krachtige functies mogelijk, zoals verzoeken ongedaan maken, opnieuw uitvoeren, in een wachtrij plaatsen en loggen, terwijl de invoker wordt ontkoppeld van de ontvanger.
Het Iterator-patroon biedt een gestandaardiseerde manier om elementen in een verzameling te doorlopen. Het verbergt de interne structuur van de verzameling en bevordert flexibele manieren van itereren.

Als je deze patronen beheerst, verbeter je de flexibiliteit en onderhoudbaarheid van je softwareontwerpen aanzienlijk.

Gratis beginnen

Leer Clean Architecture en ontwerppatronen in de praktijk met een AI-tutor — gratis

Schrijf echte code en voer die uit in je browser, krijg direct hulp van een AI-tutor die 24/7 beschikbaar is en ga verder waar je gebleven bent op het web of in de app.

Cursussen: 12
Lessen: 48

Gratis beginnen met leren Bekijk de volledige cursus

Veelgestelde vragen

Is de les “Command- en Iterator-patronen” gratis?

Ja — de volledige tekst van “Command- en Iterator-patronen” kun je hier gratis op het web lezen. Als je interactief wilt oefenen met een ingebouwde code-editor en een AI-begeleider die 24/7 beschikbaar is, en de rest van de cursus Clean Architecture en ontwerppatronen in de praktijk wilt ontgrendelen, kun je upgraden naar CoddyKit PRO. De cursus Clean Architecture en ontwerppatronen in de praktijk bevat in totaal 4 lessen.

Wat leer ik in “Command- en Iterator-patronen”?

Encapsuleer verzoeken als objecten met Command en doorloop collecties met Iterator. Je oefent met Clean Architecture en ontwerppatronen in de praktijk door code rechtstreeks in de browser uit te voeren. Een AI-begeleider die 24/7 beschikbaar is beantwoordt je vragen terwijl je de les doorwerkt.

Heb ik ervaring nodig om met Clean Architecture en ontwerppatronen in de praktijk te beginnen?

Ervaring vooraf is niet nodig. Clean Architecture en ontwerppatronen in de praktijk op CoddyKit is opgebouwd voor beginners tot gevorderden, zodat je hier of bij het begin kunt starten en in je eigen tempo kunt leren. Dit is les 2 van 4.

Hoe lang duurt de les “Command- en Iterator-patronen”?

De meeste lessen van CoddyKit duren ongeveer 5–10 minuten. Elke les is kort en interactief, zodat je gestaag vooruitgaat en op het web en in de app precies verdergaat waar je was gebleven.

Kan ik code schrijven en uitvoeren in deze les over Clean Architecture en ontwerppatronen in de praktijk?

Ja. Elke les over Clean Architecture en ontwerppatronen in de praktijk bevat een ingebouwde code-editor, zodat je rechtstreeks in je browser echte code kunt schrijven en uitvoeren en direct feedback van AI krijgt — lokale installatie is niet nodig.

Alle lessen in deze cursus

← Terug naar Clean Architecture en ontwerppatronen in de praktijk