Factory Model Design Pattern

Kennst du das Gefühl, wenn du ein neues Projekt startest und dich fühlst, als stündest du vor einem riesigen Haufen Lego-Steine? Du weißt, was du bauen willst, aber wie du all diese Einzelteile zusammensetzen sollst, erscheint dir unübersichtlich? Du bist nicht allein! Viele Entwickler kämpfen mit der Komplexität der Objekterzeugung, besonders wenn es um das Erstellen verschiedener Varianten geht.

Stell dir vor, du programmierst ein Spiel. Du brauchst verschiedene Arten von Gegnern: Zombies, Skelette, Geister. Jeder Gegnertyp hat unterschiedliche Eigenschaften und Verhaltensweisen. Würdest du für jeden Typ einen eigenen, komplizierten Erzeugungsprozess schreiben? Das wäre nicht nur mühsam, sondern auch schwer wartbar. Hier kommt der Factory Model Design Pattern ins Spiel!

Was ist der Factory Model Design Pattern?

Der Factory Model Design Pattern (auch Fabrikmethode genannt) ist ein Entwurfsmuster, das die Objekterzeugung von der eigentlichen Verwendung entkoppelt. Statt direkt mit dem new-Operator Objekte zu erzeugen, wird die Erzeugung an eine Fabrik delegiert. Diese Fabrik weiß, wie die verschiedenen Objekttypen erstellt werden und liefert sie dir auf Anfrage.

Must Read

Einfach gesagt: Die Fabrik ist wie eine Werkstatt, die verschiedene Produkte (Objekte) herstellen kann, ohne dass du dich um die Details der Herstellung kümmern musst. Du gibst einfach eine Bestellung auf (fragst nach einem bestimmten Objekttyp) und die Fabrik liefert dir das fertige Produkt.

Wie funktioniert es?

Das Factory Model Design Pattern besteht im Wesentlichen aus folgenden Komponenten:

Factory Design Pattern Explained With Simple Example: Creational Design

Produkt (Product): Ein Interface oder eine abstrakte Klasse, die die gemeinsamen Eigenschaften und Methoden aller erzeugten Objekte definiert. In unserem Spielbeispiel wäre das beispielsweise ein Gegner Interface.
Konkrete Produkte (Concrete Products): Die konkreten Implementierungen des Produkts, also die verschiedenen Arten von Objekten, die erzeugt werden können. Das wären dann Zombie, Skelett und Geist Klassen, die das Gegner Interface implementieren.
Fabrik (Factory): Ein Interface oder eine abstrakte Klasse, die eine Methode (die Fabrikmethode) definiert, die ein Objekt vom Typ Produkt zurückgibt.
Konkrete Fabriken (Concrete Factories): Die konkreten Implementierungen der Fabrik, die jeweils für die Erzeugung eines bestimmten Typs von konkretem Produkt zuständig sind. Beispielsweise eine ZombieFabrik, eine SkelettFabrik und eine GeistFabrik.

Der Ablauf ist dann folgendermaßen:

Du fragst die Fabrik nach einem bestimmten Produkttyp.
Die Fabrik erzeugt das entsprechende Objekt.
Die Fabrik gibt das erzeugte Objekt zurück.

Vorteile des Factory Model Design Pattern

Der Einsatz des Factory Model Design Pattern bietet eine Reihe von Vorteilen:

Entkopplung: Die Objekterzeugung ist von der Verwendung entkoppelt. Der Code, der die Objekte verwendet, muss nicht wissen, wie sie erzeugt werden.
Flexibilität: Es ist einfach, neue Objekttypen hinzuzufügen, ohne den bestehenden Code zu verändern. Du erstellst einfach eine neue konkrete Produktklasse und eine neue konkrete Fabrikklasse.
Wartbarkeit: Der Code ist leichter wartbar, da die Objekterzeugung an einer zentralen Stelle konzentriert ist.
Testbarkeit: Der Code ist leichter testbar, da du die Fabrik durch eine Mock-Implementierung ersetzen kannst.
Single Responsibility Principle: Jede Klasse hat eine klare Verantwortung. Die Fabrik ist für die Objekterzeugung zuständig, während die anderen Klassen für ihre spezifischen Aufgaben zuständig sind.

"Der Factory Model Design Pattern ist wie ein Schweizer Taschenmesser für die Objekterzeugung – vielseitig, praktisch und immer zur Hand, wenn du es brauchst."

Factory Method Design Pattern. Factory pattern is one of the most used

Wann solltest du das Factory Model Design Pattern einsetzen?

Das Factory Model Design Pattern ist besonders dann sinnvoll, wenn:

Du verschiedene Varianten von Objekten erstellen musst.
Die Erzeugung der Objekte komplex ist.
Du die Objekterzeugung von der Verwendung entkoppeln möchtest.
Du den Code flexibler und wartbarer machen möchtest.

Ein weiteres Beispiel: Stell dir vor, du entwickelst eine Anwendung, die verschiedene Dokumenttypen verarbeiten kann (z.B. Textdokumente, PDF-Dokumente, HTML-Dokumente). Mit dem Factory Model Design Pattern kannst du eine Fabrik erstellen, die die entsprechenden Dokumentobjekte erzeugt, je nachdem, welcher Dokumenttyp benötigt wird.

Beispiel in Pseudocode

Hier ein einfaches Beispiel in Pseudocode, um das Prinzip zu verdeutlichen:


// Produkt Interface
Interface Gegner {
  Methode angreifen()
}

// Konkrete Produkte
Klasse Zombie implementiert Gegner {
  Methode angreifen() { // Zombie-Angriff }
}

Klasse Skelett implementiert Gegner {
  Methode angreifen() { // Skelett-Angriff }
}

// Fabrik Interface
Interface GegnerFabrik {
  Methode erschaffeGegner() : Gegner
}

// Konkrete Fabriken
Klasse ZombieFabrik implementiert GegnerFabrik {
  Methode erschaffeGegner() : Gegner {
    return new Zombie()
  }
}

Klasse SkelettFabrik implementiert GegnerFabrik {
  Methode erschaffeGegner() : Gegner {
    return new Skelett()
  }
}

// Verwendung
Funktion spieleSzene(GegnerFabrik fabrik) {
  gegner = fabrik.erschaffeGegner()
  gegner.angreifen()
}

// Beispielaufruf
spieleSzene(new ZombieFabrik()) // Erzeugt einen Zombie
spieleSzene(new SkelettFabrik()) // Erzeugt ein Skelett

Fazit

Der Factory Model Design Pattern ist ein mächtiges Werkzeug, um die Komplexität der Objekterzeugung zu bewältigen. Er ermöglicht es dir, flexiblen, wartbaren und testbaren Code zu schreiben. Wenn du also das nächste Mal vor der Herausforderung stehst, verschiedene Varianten von Objekten zu erstellen, denke an die Fabrik – sie könnte die Lösung für dein Problem sein!

Experimentiere mit dem Pattern und entdecke, wie er deine Projekte vereinfachen und verbessern kann!