Clean Architecture og designmønstre i praksis · leksjon

Command- og Iterator-mønstre

Kapsle forespørsler som objekter med Command, og gå gjennom samlinger med Iterator.

Leksjon 2 av 411 trinn

Command- og Iterator-mønstre er en gratis leksjon i Clean Architecture og designmønstre i praksis på CoddyKit. Dette er leksjon 2 av 4. Du kan lese hele leksjonen gratis nedenfor – og deretter øve praktisk i nettleseren med en innebygd kodeeditor og en AI-veileder som er tilgjengelig døgnet rundt. Den er en del av læringsløpet i Clean Architecture og designmønstre i praksis, og fremdriften din synkroniseres mellom nettet og CoddyKit-appen. Kurset i Clean Architecture og designmønstre i praksis inneholder totalt 4 leksjoner.

Hva er kommandomønsteret?

Kommandomønsteret er et atferdsdesignmønster som gjør en forespørsel om til et selvstendig objekt. Dette objektet inneholder all informasjon om forespørselen, inkludert metoden som skal kalles og parameterne den trenger.

Tenk på det som å legge en instruksjon i en pakke. Deretter kan du sende denne pakken rundt, legge den i en kø eller til og med angre den senere, uten at avsenderen trenger å vite hvordan instruksjonen utføres.

Kommandoens hovedkomponenter

For å forstå kommandomønsteret kan vi se på de viktigste aktørene:

Command: Et grensesnitt eller en abstrakt klasse som deklarerer en execute()-metode.
ConcreteCommand: Implementerer Command-grensesnittet og kobler et bestemt Receiver-objekt til en handling.
Receiver: Objektet som utfører selve arbeidet. Det vet hvordan operasjonen skal gjennomføres.
Invoker: Ber kommandoen utføre forespørselen sin. Den kjenner ikke detaljene i operasjonen eller mottakeren.
Client: Oppretter et ConcreteCommand-objekt og angir objektets Receiver.

Kommandomønsteret i praksis

La oss se for oss et smarthjemsystem der du vil styre en lampe. Uten kommandomønsteret ville fjernkontrollen kalt light.turnOn() eller light.turnOff() direkte.

Med kommandomønsteret vet fjernkontrollen bare hvordan den skal «utføre en kommando». Den bryr seg ikke om kommandoen slår på en lampe, åpner en garasjeport eller spiller av musikk. Dette gjør fjernkontrollen (Invoker) svært fleksibel!

Kode: Kommando for å slå lys på og av

Her er et enkelt Java-eksempel som viser kommandomønsteret for styring av en lampe. Legg merke til hvordan RemoteControl (Invoker) bare samhandler med Command-grensesnittet.

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

Fordeler med kommandomønsteret

Kommandomønsteret har flere betydelige fordeler:

Frikobling: Invokeren er frikoblet fra mottakeren, noe som reduserer avhengighetene.
Angre/gjøre om: Kommandoer kan lagres i en historikkliste, noe som gjør det enklere å implementere funksjonalitet for å angre og gjøre om.
Kølegging og logging: Forespørsler kan legges i kø, logges og utføres på ulike tidspunkter.
Utvidbarhet: Når nye kommandoer legges til, trenger ikke den eksisterende invoker-koden å endres.

Hva er iteratormønsteret?

Iteratormønsteret er et atferdsdesignmønster som gir en måte å få sekvensiell tilgang til elementene i et aggregert objekt (for eksempel en liste eller tabell) uten å eksponere den underliggende representasjonen.

Se for deg at du har en spilleliste med sanger. En iterator lar deg gå gjennom hver sang én etter én (neste, forrige og så videre) uten at du trenger å vite om spillelisten er lagret som en tabell, en lenket liste eller noe helt annet.

Iteratorens hovedkomponenter

Iteratormønsteret består av disse hovedkomponentene:

Iterator: Et grensesnitt som definerer metoder for å få tilgang til og gå gjennom elementer (for eksempel hasNext(), next()).
ConcreteIterator: Implementerer Iterator-grensesnittet og holder oversikt over gjeldende posisjon under gjennomgangen.
Aggregate: Et grensesnitt eller en abstrakt klasse som definerer en metode for å opprette et Iterator-objekt (for eksempel createIterator()).
ConcreteAggregate: Implementerer Aggregate-grensesnittet og returnerer en instans av ConcreteIterator.

Iteratormønsteret i praksis

De fleste programmeringsspråk har innebygde iteratorer (for eksempel Javas Iterator eller itererbare objekter i Python). Noen ganger lager du imidlertid en egendefinert samling der du må definere din egen logikk for gjennomgang.

Hvis du for eksempel har en egendefinert klasse kalt MyStringList som lagrer strenger internt, kan en iterator la ekstern kode gå gjennom disse strengene uten å vite om MyStringList internt bruker en tabell, en lenket liste eller en trestruktur.

Kode: Iterator for en egendefinert liste

Dette Java-eksempelet viser hvordan du oppretter en egendefinert StringList og en Iterator for den. Main-metoden kan gå gjennom listen ved hjelp av iteratoren uten å kjenne den interne tabellen.

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

Rask sjekk: Designmønstre

Du har lært om to kraftige atferdsmønstre. La oss teste forståelsen din.

Besvar den i den interaktive leksjonen

Oppsummering: Kommando og iterator

Godt jobbet! I denne leksjonen utforsket vi to viktige atferdsdesignmønstre:

Kommandomønsteret kapsler inn en forespørsel som et objekt. Det muliggjør avanserte funksjoner som angre/gjøre om, kølegging og logging av forespørsler, samtidig som invokeren frikobles fra mottakeren.
Iteratormønsteret gir en standardisert måte å gå gjennom elementene i en samling på. Det skjuler samlingens interne struktur og fremmer fleksible metoder for iterasjon.

Når du behersker disse mønstrene, vil det forbedre fleksibiliteten og vedlikeholdbarheten til programvaredesignene dine betydelig.

Gratis å komme i gang

Lær deg Clean Architecture og designmønstre i praksis med en AI-veileder – gratis

Skriv og kjør ekte kode i nettleseren, få umiddelbar hjelp fra en AI-veileder som er tilgjengelig døgnet rundt, og fortsett der du slapp – på nettet eller i appen.

Kurs: 12
Leksjoner: 48

Start læringen gratis Se hele kurset

Ofte stilte spørsmål

Er leksjonen «Command- og Iterator-mønstre» gratis?

Ja – hele teksten i «Command- og Iterator-mønstre» er gratis å lese her på nettet. For å øve interaktivt med en innebygd kodeeditor og en AI-veileder som er tilgjengelig døgnet rundt, og for å låse opp resten av Clean Architecture og designmønstre i praksis-kurset, kan du oppgradere til CoddyKit PRO. Kurset i Clean Architecture og designmønstre i praksis inneholder totalt 4 leksjoner.

Hva lærer jeg i «Command- og Iterator-mønstre»?

Kapsle forespørsler som objekter med Command, og gå gjennom samlinger med Iterator. Du øver på Clean Architecture og designmønstre i praksis med praktisk kode som du kjører direkte i nettleseren, mens en AI-veileder som er tilgjengelig døgnet rundt, svarer på spørsmålene dine mens du jobber deg gjennom leksjonen.

Trenger jeg erfaring for å begynne med Clean Architecture og designmønstre i praksis?

Ingen tidligere erfaring er nødvendig. Clean Architecture og designmønstre i praksis på CoddyKit er lagt opp for både nybegynnere og viderekomne, så De kan begynne her eller helt fra start og lære i Deres eget tempo. Dette er leksjon 2 av 4.

Hvor lang tid tar leksjonen «Command- og Iterator-mønstre»?

De fleste CoddyKit-leksjoner tar omtrent 5–10 minutter. Hver leksjon er kort og interaktiv, slik at De gjør jevne fremskritt og kan fortsette akkurat der De slapp – både på nettet og i appen.

Kan jeg skrive og kjøre kode i denne Clean Architecture og designmønstre i praksis-leksjonen?

Ja. Alle Clean Architecture og designmønstre i praksis-leksjoner har en innebygd kodeeditor, slik at De kan skrive og kjøre ekte kode direkte i nettleseren og få umiddelbar tilbakemelding fra AI – uten lokal konfigurering.

Alle leksjonene i dette kurset

← Tilbake til Clean Architecture og designmønstre i praksis