Wie funktioniert das Factory Method Pattern?

1. Abstrakte Produktklasse: Es gibt eine abstrakte Klasse oder Schnittstelle, die die zu erstellenden Objekte beschreibt.
2. Konkrete Produktklassen: Diese Klassen implementieren die abstrakte Produktklasse und bieten die spezifische Funktionalität der Objekte.
3. Abstrakte Fabrik: Eine abstrakte Klasse oder Schnittstelle, die eine Methode (factory method) definiert, um die Objekte zu erstellen.
4. Konkrete Fabriken: Diese Fabriken implementieren die abstrakte Fabrik und entscheiden, welches konkrete Produkt (Objekt) instanziiert wird.

Das Factory Method Pattern wird also nicht durch einen einfachen Konstruktor zum Erstellen von Objekten ersetzt, sondern nutzt eine Methode, die von einer abstrakten Klasse bereitgestellt wird, um das zu erzeugende Objekt zu spezifizieren. Diese Methode wird dann von Unterklassen (den konkreten Fabriken) überschrieben, die entscheiden, welches konkrete Produkt zurückgegeben wird.

Schlüsselkomponenten:

1. Produkt: Das Objekt, das von der Factory-Methode erzeugt wird. Es definiert die allgemeine Schnittstelle für alle Produkte.
2. Konkretes Produkt: Eine konkrete Implementierung des Produkts.
3. Fabrik: Eine abstrakte Fabrikklasse, die eine create-Methode zur Erstellung von Objekten definiert.
4. Konkrete Fabrik: Eine Unterklasse der abstrakten Fabrik, die die spezifische create-Methode implementiert und das konkrete Produkt erstellt.

Beispiel für das Factory Method Pattern:

Nehmen wir an, wir haben ein System, das verschiedene Arten von Dokumenten erstellt (z. B. PDF und Word-Dokumente). Anstatt direkt in unserem Code die konkrete Klasse eines Dokuments zu erstellen, verwenden wir eine Fabrikmethode, um diese Objekte zu instanziieren.

pythonKopierenfrom abc import ABC, abstractmethod

# Abstrakte Produktklasse
class Document(ABC):
    @abstractmethod
    def display(self):
        pass

# Konkrete Produktklassen
class PDFDocument(Document):
    def display(self):
        return "Anzeige eines PDF-Dokuments"

class WordDocument(Document):
    def display(self):
        return "Anzeige eines Word-Dokuments"

# Abstrakte Fabrikklasse
class DocumentFactory(ABC):
    @abstractmethod
    def create_document(self) -> Document:
        pass

# Konkrete Fabriken
class PDFDocumentFactory(DocumentFactory):
    def create_document(self) -> Document:
        return PDFDocument()

class WordDocumentFactory(DocumentFactory):
    def create_document(self) -> Document:
        return WordDocument()

# Client-Code
def client_code(factory: DocumentFactory):
    document = factory.create_document()
    print(document.display())

# Fabriken verwenden
pdf_factory = PDFDocumentFactory()
word_factory = WordDocumentFactory()

client_code(pdf_factory)   # Ausgabe: Anzeige eines PDF-Dokuments
client_code(word_factory)  # Ausgabe: Anzeige eines Word-Dokuments

Erklärung des Beispiels:

• Document (Abstrakte Produktklasse): Eine allgemeine Schnittstelle für alle Dokumenttypen.
• PDFDocument und WordDocument (Konkrete Produktklassen): Diese Klassen implementieren die display-Methode und bieten die spezifische Logik für das Anzeigen von PDF bzw. Word-Dokumenten.
• DocumentFactory (Abstrakte Fabrik): Eine abstrakte Fabrik, die eine Methode create_document() definiert, um ein Dokument zu erstellen.
• PDFDocumentFactory und WordDocumentFactory (Konkrete Fabriken): Diese Klassen implementieren die create_document()-Methode, die entweder ein PDF- oder Word-Dokument zurückgibt.