Clean Architecture & Design Patterns in Practice · Ders

Komut ve Yineleyici Kalıpları

İstekleri Komut ile nesne olarak kapsülleyin ve koleksiyonlar üzerinde Yineleyici ile dolaşın.

Komut ve Yineleyici Kalıpları, CoddyKit'te ücretsiz bir Clean Architecture & Design Patterns in Practice dersidir. Bu, 4 dersinin 2. dersidir. Aşağıdan dersin tamamını ücretsiz okuyabilir, sonra tarayıcıda yerleşik kod editörü ve 7/24 yapay zeka koçu ile uygulamalı olarak pratik yapabilirsin. Bu, Clean Architecture & Design Patterns in Practice öğrenme yolunun bir parçasıdır ve ilerlemeniz web ve CoddyKit uygulaması arasında senkronize olur. Clean Architecture & Design Patterns in Practice kursu toplamda 4 dersten oluşur.

Bu dersin bazı bölümleri henüz çevrilmemiş olup İngilizce olarak gösterilmektedir.

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.

Sıkça Sorulan Sorular

“Komut ve Yineleyici Kalıpları” dersi ücretsiz mi?

Evet — “Komut ve Yineleyici Kalıpları” dersin tüm metni burada web'de ücretsiz olarak okunabilir. Etkileşimli olarak pratik yapmak (yerleşik kod editörü ve 7/24 yapay zeka koçu) ve Clean Architecture & Design Patterns in Practice kursunun geri kalanını açmak için CoddyKit PRO'ya yükselt. Clean Architecture & Design Patterns in Practice kursu toplamda 4 dersten oluşur.

“Komut ve Yineleyici Kalıpları” dersinde ne öğreneceğim?

İstekleri Komut ile nesne olarak kapsülleyin ve koleksiyonlar üzerinde Yineleyici ile dolaşın. Clean Architecture & Design Patterns in Practice ile uygulamalı kodu tarayıcıda doğrudan çalıştırarak pratik yaparsın ve 7/24 yapay zeka koçu dersi çalışırken sorularını yanıtlar.

Clean Architecture & Design Patterns in Practice öğrenmeye başlamak için deneyim gerekli mi?

Önceden deneyim gerekmez. CoddyKit'te Clean Architecture & Design Patterns in Practice, başlangıçtan ileri seviyeye kadar yapılandırıldığı için buradan başlayabilir veya başından başlayıp kendi hızında ilerleme yapabilirsin. Bu, 4 dersinin 2. dersidir.

“Komut ve Yineleyici Kalıpları” dersi ne kadar sürer?

Çoğu CoddyKit dersi yaklaşık 5–10 dakika sürer. Her biri kısa ve etkileşimli olduğu için sabit ilerleme yaparsın ve web ile uygulama arasında tam olarak bıraktığın yerden devam edebilirsin.

Bu Clean Architecture & Design Patterns in Practice dersinde kod yazıp çalıştırabilir miyim?

Evet. Her Clean Architecture & Design Patterns in Practice dersi yerleşik bir kod editörü içerir, bu sayede tarayıcıda gerçek kod yazıp çalıştırabilir ve anlık yapay zeka geri bildirimi alırsın — yerel kurulum gerekli değildir.

Bu kursun tüm dersleri

← Clean Architecture & Design Patterns in Practice Sayfasına Dön