Was ist eine Factory-Klasse? Eine Factory-Klasse ist eine Klasse, die ein oder mehrere Objekte verschiedener Klassen erstellt.

Das Factory-Muster ist wohl das am h?ufigsten verwendete Entwurfsmuster in der Softwareentwicklung. In diesem Artikel werde ich die Entwurfsmuster ?Simple Factory“ und ?Factory Method“ anhand eines einfachen Beispielproblems ausführlich erl?utern.

Das einfache Fabrikmuster

Angenommen, wir m?chten ein System erstellen, das zwei Arten von Tieren unterstützt, z. B. Hund und Katze. Jede der Tierklassen sollte über eine Methode verfügen, die den Ger?uschtyp des Tieres erzeugt. Jetzt m?chte ein Kunde das System verwenden, um Tierger?usche basierend auf den Benutzereingaben des Kunden zu erzeugen. Eine grundlegende L?sung für das obige Problem kann wie folgt geschrieben werden:

from abc import ABC, abstractmethod

class Animal(ABC):
    @abstractmethod
    def make_sound(self):
        pass

class Dog(Animal):
    def make_sound(self):
        print("Bhow Bhow!")

class Cat(Animal):
    def make_sound(self):
        print("Meow Meow!")

Mit dieser L?sung wird unser Kunde das System wie folgt nutzen

## client code
if __name__ == '__main__':
    animal_type = input("Which animal should make sound Dog or Cat?")
    if animal_type.lower() == 'dog':
        Dog().make_sound()
    elif animal_type.lower() == 'cat':
        Cat().make_sound()

Unsere L?sung wird gut funktionieren, aber Simple Factory Pattern sagt, dass wir es besser machen k?nnen. Warum? Wie Sie im obigen Client-Code gesehen haben, muss der Client entscheiden, welche unserer Tierklassen er jeweils aufrufen m?chte. Stellen Sie sich vor, das System h?tte beispielsweise zehn verschiedene Tierklassen. Sie k?nnen bereits erkennen, wie problematisch die Nutzung des Systems für unseren Kunden sein wird.

Das Simple Factory-Muster besagt also einfach, dass wir das System für den Client entscheiden lassen, anstatt den Client entscheiden zu lassen, welche Klasse aufgerufen werden soll.

Um das Problem mithilfe des Simple Factory-Musters zu l?sen, müssen wir lediglich eine Factory-Klasse mit einer Methode erstellen, die sich um die Erstellung von Tierobjekten kümmert.

...
...
class AnimalFactory:
    def make_sound(self, animal_type):
        return eval(animal_type.title())().make_sound()

Mit diesem Ansatz wird der Client-Code zu:

## client code
if __name__ == '__main__':
    animal_type = input("Which animal should make sound Dog or Cat?")
    AnimalFactory().make_sound(animal_type)

Zusammenfassend geht es beim Simple Factory-Muster darum, eine Factory-Klasse zu erstellen, die die Objekterstellung im Namen eines Clients übernimmt.

Factory-Methodenmuster

Um auf unsere Problemstellung zurückzukommen, ein System zu haben, das nur zwei Tierarten (Hund und Katze) unterstützt: Was w?re, wenn diese Einschr?nkung aufgehoben würde und unser System bereit w?re, jede Tierart zu unterstützen? Natürlich konnte es sich unser System nicht leisten, Implementierungen für Millionen von Tieren bereitzustellen. Hier kommt das Factory Method Pattern zur Rettung.

Im Factory-Methodenmuster definieren wir eine abstrakte Klasse oder Schnittstelle zum Erstellen von Objekten, aber anstatt dass die Factory für die Objekterstellung verantwortlich ist, wird die Verantwortung auf die Unterklasse übertragen, die entscheidet, welche Klasse instanziiert werden soll.

Schlüsselkomponenten des Factory-Methodenmusters

1. Creator: Der Creator ist eine abstrakte Klasse oder Schnittstelle. Es deklariert die Factory-Methode, eine Methode zum Erstellen von Objekten. Der Creator stellt eine Schnittstelle zum Erstellen von Produkten bereit, spezifiziert jedoch nicht deren konkrete Klassen.

2. Concrete Creator: Concrete Creators sind die Unterklassen des Creators. Sie implementieren die Factory-Methode und entscheiden, welche konkrete Produktklasse instanziiert werden soll. Mit anderen Worten: Jeder Concrete Creator ist auf die Herstellung eines bestimmten Produkttyps spezialisiert.

3. Produkt: Das Produkt ist eine weitere abstrakte Klasse oder Schnittstelle. Es definiert den Typ der Objekte, die die Factory-Methode erstellt. Diese Produkte haben eine gemeinsame Schnittstelle, ihre konkreten Implementierungen k?nnen jedoch variieren.

4. Betonprodukt: Betonprodukte sind die Unterklassen des Produkts. Sie stellen die spezifischen Implementierungen der Produkte bereit. Jedes konkrete Produkt entspricht einem Objekttyp, der mit der Factory-Methode erstellt wurde.

Unten sehen Sie, wie unser Systemcode unter Verwendung des Factory-Methodenmusters aussehen wird:

Schritt 1: Definieren des Produkts

from abc import ABC, abstractmethod

class Animal(ABC):
    @abstractmethod
    def make_sound(self):
        pass

class Dog(Animal):
    def make_sound(self):
        print("Bhow Bhow!")

class Cat(Animal):
    def make_sound(self):
        print("Meow Meow!")

Schritt 2: Betonprodukte erstellen

## client code
if __name__ == '__main__':
    animal_type = input("Which animal should make sound Dog or Cat?")
    if animal_type.lower() == 'dog':
        Dog().make_sound()
    elif animal_type.lower() == 'cat':
        Cat().make_sound()

Schritt 3: Den Sch?pfer definieren

...
...
class AnimalFactory:
    def make_sound(self, animal_type):
        return eval(animal_type.title())().make_sound()

Schritt 4: Konkrete Sch?pfer implementieren

## client code
if __name__ == '__main__':
    animal_type = input("Which animal should make sound Dog or Cat?")
    AnimalFactory().make_sound(animal_type)

Und der Kunde kann die L?sung wie folgt nutzen:

from abc import ABC, abstractmethod

class Animal(ABC):
    @abstractmethod
    def make_sound(self):
        pass

Mit der Factory Method Pattern-L?sung k?nnen Kunden das System erweitern und bei Bedarf benutzerdefinierte Tierimplementierungen bereitstellen.

Vorteile des Factory-Methodenmusters

1. Entkopplung: Es entkoppelt den Client-Code von den konkreten Klassen, reduziert Abh?ngigkeiten und verbessert die Codestabilit?t.

2. Flexibilit?t: Es bringt viel Flexibilit?t mit sich und macht den Code generisch, sodass er für die Instanziierung nicht an eine bestimmte Klasse gebunden ist. Auf diese Weise sind wir von der Schnittstelle (Product) abh?ngig und nicht von der ConcreteProduct-Klasse.

3. Erweiterbarkeit: Neue Produktklassen k?nnen hinzugefügt werden, ohne den vorhandenen Code zu ?ndern, wodurch ein Offen-Geschlossen-Prinzip gef?rdert wird.

Abschluss

Das Entwurfsmuster der Factory-Methode bietet eine systematische M?glichkeit, Objekte zu erstellen und gleichzeitig den Code wartbar und anpassungsf?hig zu halten. Es eignet sich hervorragend für Szenarien, in denen Objekttypen variieren oder sich weiterentwickeln.

Frameworks, Bibliotheken, Plug-in-Systeme und Software-?kosysteme profitieren von seiner Leistungsf?higkeit. Es erm?glicht Systemen, sich an sich ?ndernde Anforderungen anzupassen.

Es sollte jedoch mit Bedacht und unter Berücksichtigung der spezifischen Anforderungen der Anwendung und des Prinzips der Einfachheit verwendet werden. Bei richtiger Anwendung kann das Factory-Methodenmuster erheblich zum Gesamtdesign und zur Architektur eines Softwaresystems beitragen.

Viel Spa? beim Codieren!!!

Das obige ist der detaillierte Inhalt vonVerst?ndnis der Fabrik- und Fabrikmethoden-Entwurfsmuster. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!