html button
print (Windows_button.render ()) # Ausgabe:Windows -Schaltfläche (UI -spezifisch)
`` `
* Hinweise: Mit der Werksmethode können Sie neue Schaltflächentypen hinzufügen, ohne die "ButtonFactory" -Klasse direkt zu ändern (das Prinzip/das geschlossene Abschluss).
3. Strategie
* Zweck: Definiert eine Familie von Algorithmen, verkauft jeden und macht sie austauschbar. Durch Strategie variieren der Algorithmus unabhängig von Kunden, die ihn verwenden.
* Wann zu verwenden: Wenn Sie mehrere Möglichkeiten haben, eine bestimmte Aufgabe auszuführen und zur Laufzeit einfach zwischen ihnen wechseln zu können.
* Einfaches Beispiel (Python):
`` `Python
KlassenzahlungStrategy:
Def Pay (Selbst, Betrag):
ERHALTENDERPLEMPLETEDERROR () erhöhen ()
Klassenkreditkardierung (PaymentStrategy):
def __init __ (self, card_number, expiry_date, cvv):
self.card_number =card_number
self.expiry_date =expiry_date
self.cvv =cvv
Def Pay (Selbst, Betrag):
print (f "$ {betragen} mit Kreditkarte:{self.card_number}"))
Klasse PayPalPayment (PaymentStrategy):
Def __init __ (Selbst, E -Mail):
self.email =E -Mail
Def Pay (Selbst, Betrag):
print (f "$ {betragen} mit paypal:{self.email}"))
Klasseneinkäufe:
def __init __ (self, payment_strategy:paymentStrategy):# hier eingespritzte Strategie
self.payment_strategy =payment_strategy
self.total =0
Def add_item (Selbst, Preis):
self.total +=Preis
Def Checkout (Selbst):
self.payment_strategy.pay (self.total)
# Nutzung
Credit_card =CreditCardPayment ("1234-5678-9012-3456", "12/24", "123")
paypal =paypalPayment ("[email protected]")
Cart1 =ShoppingCart (Credit_card)
cart1.add_item (100)
cart1.add_item (50)
Cart1.Checkout () # Ausgabe:Zahlung von 150 US-Dollar mit Kreditkarte:1234-5678-9012-3456
Cart2 =ShoppingCart (PayPal)
cart2.add_item (200)
Cart2.Checkout () # Ausgabe:$ 200 mit PayPal:[email protected] zahlen
`` `
* Hinweise: Das "ShoppingCart" muss die spezifische Zahlungsmethode nicht kennen. Es verwendet einfach die injizierte "paymentStrategy", um die Zahlung auszuführen. Dies erleichtert einfach, neue Zahlungsmethoden hinzuzufügen, ohne die "ShoppingCart" -Klasse zu ändern.
4. Beobachter
* Zweck: Definiert eine Eins-zu-Viele-Abhängigkeit zwischen Objekten, sodass bei einem Objekt den Zustand ändert, alle seine Angehörigen automatisch benachrichtigt und aktualisiert werden.
* Wann zu verwenden: Wenn eine Änderung in einem Objekt andere Objekte ändern muss und die Objekte nicht festgekoppelt sind. Beispiele:Ereignisbearbeitung, UI-Updates, Architektur für Modell-View-Controller (MVC).
* Einfaches Beispiel (Python):
`` `Python
Klassenfach:
def __init __ (selbst):
self._observers =[]
Def Attach (Selbst, Beobachter):
self._observervers.append (Beobachter)
Def detach (Selbst, Beobachter):
self._observervers.remove (Beobachter)
Def Benachrichtigung (Selbst, Nachricht):
Für Beobachter in self._observers:
Observer.update (Nachricht)
Klassenbeobachter:
Def Update (Selbst, Nachricht):
ERHALTENDERPLEMPLETEDERROR () erhöhen ()
Klasse ConcreteObservera (Beobachter):
Def Update (Selbst, Nachricht):
print (f "Beobachter A empfangen:{message}")
Klasse ConcreteObserverb (Beobachter):
Def Update (Selbst, Nachricht):
print (f "Beobachter B empfangen:{message.upper ()}")
# Nutzung
Subjekt =Subjekt ()
observer_a =konkreterobservera ()
observer_b =konkreterobserverb ()
Betreff.attach (observer_a)
Betreff.attach (observer_b)
Betreff.Notify ("Hallo, Welt!") # Ausgabe:Beobachter A erhalten:Hallo, Welt!
# Observer B erhalten:Hallo, Welt!
Betreff.Detach (observer_a)
Betreff.
`` `
* Hinweise: Das "Subjekt" unterhält eine Liste von "Beobachtern". Wenn sich der Status des Subjekts ändert (in diesem Fall, wenn "Benachrichtigung" aufgerufen wird), wird die Liste durch die Liste iteriert und die "Update" -Methode für jeden "Observer" aufgerufen.
5. Vorlagenmethode
* Zweck: Definiert das Skelett eines Algorithmus in einer Basisklasse, lässt jedoch Unterklassen spezifische Schritte des Algorithmus überschreiben, ohne seine Struktur zu ändern.
* Wann zu verwenden: Wenn Sie eine Reihe von Schritten haben, die in einer bestimmten Reihenfolge ausgeführt werden müssen, können einige dieser Schritte je nach spezifischer Implementierung variieren.
* Einfaches Beispiel (Python):
`` `Python
KlassendataProzessor:
Def process_data (self):
self.read_data ()
self.validate_data ()
self.transform_data ()
self.save_data ()
drucken ("Datenverarbeitung vollständig.")
Def read_data (Selbst):
ERHALTENDERPLEMPLETEDERROR () erhöhen ()
Def validate_data (Selbst):
print ("Standardvalidierung:Überprüfung auf Nullwerte.")
Def Transform_data (Selbst):
ERHALTENDERPLEMPLETEDERROR () erhöhen ()
Def Save_data (Selbst):
ERHALTENDERPLEMPLETEDERROR () erhöhen ()
Klasse CSVDATAPROCESSOR (DATAPROCESSOR):
Def read_data (Selbst):
print ("Daten aus der CSV -Datei lesen").
Def Transform_data (Selbst):
print ("CSV -Daten transformieren").)
Def Save_data (Selbst):
Druck ("Daten in der Datenbank speichern.")
Klasse jSondataprozessor (Dataprozessor):
Def read_data (Selbst):
print ("Daten aus der JSON -Datei lesen").)
Def validate_data (Selbst):
print ("Benutzerdefinierte Validierung für JSON -Daten:Schema überprüfen.")
Def Transform_data (Selbst):
print ("JSON -Daten transformieren".))
Def Save_data (Selbst):
Print ("Daten in JSON -Datei speichern").
# Nutzung
CSV_PROCESSOR =CSVDATAPROCESSOR ()
CSV_PROCESSOR.PROCESS_DATA ()
# Ausgabe:
# Daten aus der CSV -Datei lesen.
# Standardvalidierung:Überprüfung auf Nullwerte.
# CSV -Daten transformieren.
# Daten in der Datenbank speichern.
# Datenverarbeitung vollständig.
JSON_PROCESSOR =JSONDATAPROCESSOR ())
JSON_PROCESSOR.PROCESS_DATA ()
# Ausgabe:
# Daten aus der JSON -Datei lesen.
# Benutzerdefinierte Validierung für JSON -Daten:Schema überprüfen.
# JSON -Daten transformieren.
# Daten in der JSON -Datei speichern.
# Datenverarbeitung vollständig.
`` `
* Hinweise: Der "DataProcessor" definiert die Gesamtstruktur des Datenverarbeitungsalgorithmus. Unterklassen wie `csvdataprocessor` und` jSondataprocessor` bieten spezifische Implementierungen für die Schritte `read_data`,` transform_data` und `save_data an. Der Schritt `validate_data` kann überschrieben oder die Standardimplementierung verwenden.
6. Dekorateur
* Zweck: Fügt dynamisch Verantwortlichkeiten zu einem Objekt hinzu, ohne seine Klasse zu ändern. Dekorateure bieten eine flexible Alternative zur Subklassierung, um die Funktionalität zu erweitern.
* Wann zu verwenden: Wenn Sie zur Laufzeit einem Objekt Funktionen hinzufügen möchten, ohne andere Objekte derselben Klasse zu beeinflussen. Nützlich zum Hinzufügen von Protokollierung, Caching oder Autorisierung.
* Einfaches Beispiel (Python):
`` `Python
Klassenkaffee:
def get_cost (self):
Rückkehr 5
Def get_description (Selbst):
Rückgabe "Kaffee"
Klasse CoffeeDecorator:
def __init __ (Selbst, Kaffee):
self._coffee =kaffee
def get_cost (self):
return self._coffee.get_cost ()
Def get_description (Selbst):
return self._coffee.get_description ()
Klasse MilkDecorator (CoffeeedCorator):
def get_cost (self):
return self._coffee.get_cost () + 2
Def get_description (Selbst):
return self._coffee.get_description () + ", milch"
Klasse Sugardecorator (CoffeeDecorator):
def get_cost (self):
return self._coffee.get_cost () + 1
Def get_description (Selbst):
return self._coffee.get_description () + ", Zucker"
# Nutzung
Kaffee =Kaffee ()
print (f "{coffee.get_description ()} - Kosten:$ {coffee.get_cost ()}") # Ausgabe:Kaffee - Kosten:$ 5
milch_coffee =milchDecorator (Kaffee)
print (f "{milch_coffee.get_description ()} - Kosten:$ {milch_coffee.get_cost ()}") # Ausgabe:Kaffee, Milch - Kosten:$ 7
SUCKE_MILK_COFFEE =SUGARDECORATOR (milch_coffee)
print (f "{sugar_milk_coffee.get_description ()} - Kosten:$ {sugar_milk_coffee.get_cost ()}") # Ausgabe:Kaffee, Milch, Zucker - Kosten:$ 8
`` `
* Hinweise: Der "CoffeeDecorator" bietet eine Grundklasse für Dekoratoren. Jeder Dekorateur (z. B. "MilkDecorator", "Sugardecorator") umhüllt das ursprüngliche "Kaffee" -Objekt und fügt seine eigene Funktionalität hinzu (in diesem Fall, die Kosten und Beschreibung hinzufügen).
wichtige Überlegungen zur Auswahl eines Musters:
* das Problem verstehen: Definieren Sie klar das Problem, das Sie lösen möchten, bevor Sie nach einem Muster greifen. Wenden Sie nicht blind Muster an. Verwenden Sie sie als Tools, um Ihren Code zu verbessern.
* Einfachheit: Beginnen Sie mit der einfachsten Lösung, die Ihren Anforderungen entspricht. Nicht vorzeitig zu übergießen.
* Kontext: Das beste Muster hängt vom spezifischen Kontext Ihres Projekts, der Sprache und der vorhandenen Codebasis ab.
* Tests: Konstruktionsmuster sollten Ihren Code nachweisbarer machen, nicht weniger. Stellen Sie sicher, dass Sie Einheitstests für die von Ihnen verwendeten Komponenten problemlos schreiben können.
Dies sind nur einige Beispiele für einfache Designmuster. Wenn Sie mehr Erfahrung sammeln, lernen Sie, Situationen zu erkennen, in denen diese und andere Muster angewendet werden können, um robustere, wartbare und wiederverwendbare Code zu erstellen. Viel Glück!
