[PYTHON] Ich habe über Designmuster studiert (persönliches Memo) Teil 4 (AbstractFactory-Muster, Brückenmuster, Strategiemuster)
Einführung
Dieser Artikel ist ein persönliches Studienmemo. Ich schreibe einen Artikel, der von der Besessenheit getrieben ist, dass das, was ich eingebe, ausgegeben werden muss. Ich schreibe diesen Artikel über Qiita in der Hoffnung, dass jemand, der damit vertraut ist, auf Fehler hinweisen und Ratschläge geben kann.
Ich lebe ein Berufsleben als Ingenieur, aber ich habe nicht richtig über Entwurfsmuster gelernt, also habe ich versucht zu studieren.
Was ist hier beschrieben https://github.com/ck-fm0211/notes_desigh_pattern Ich lade auf.
Vergangenes Protokoll
Ich habe über Entwurfsmuster (persönliches Memo) Teil 1 studiert Ich habe über Entwurfsmuster (persönliches Memo) Teil 2 studiert Ich habe über Entwurfsmuster (persönliches Memo) Teil 3 studiert
Abstraktes Fabrikmuster
- Ein Muster zum endgültigen Erstellen einer Reihe von Objekten, die Konsistenz erfordern, indem eine Klasse vorbereitet wird, die sich auf das Erstellen von Instanzen spezialisiert hat. --Beispiel
- Überlegen Sie sich ein Programm, um ein "Auto" zu erstellen
- Versuchen Sie, dem variablen Auto, das ein "Auto" -Objekt ist, Reifen und Griffe hinzuzufügen.
car.add_tire(CarTire());
car.add_handle(CarHandle());
―― Es kann vorkommen, dass ein anderer Reifen (Fahrradreifen) aufgrund eines Fehlers des Programmierers übergeben wird.
car.add_tire(BicycleTire());
car.add_handle(CarHandle());
- Es ist möglich, ein Objekt zu verwenden, das nicht verwendet werden sollte
- Bereiten Sie in einem solchen Fall eine Factory-Klasse vor, die sich um das Erstellen einer Reihe von Objekten kümmert, die zum Erstellen eines Autos erforderlich sind. Verwenden Sie diese Factory-Klasse zum Erstellen von Objekten, wenn Sie Objekte wie Reifen und Griffe erstellen. Durch die Generierung von ist es möglich, die oben genannten Fehler zu vermeiden.
- Durch Ändern dieser Factory-Klasse können Sie eine Reihe von zu verwendenden Objekten ändern.
Eigentlich verwenden
Gegenstand
――Denken Sie daran, einen "Topf" zu machen
- Komponente --Suppe
- Hauptbestandteile (Protein) --Gemüse --Andere Zutaten
- Die HotPot-Klasse, die einen Pot darstellt, ist wie folgt definiert.
# -*- coding:utf-8 -*-
class HotPot:
pot = None
soup = None
protein = None
vegetables = []
other_ingredients = []
@staticmethod
def hot_pot(pot):
HotPot.pot = pot
@staticmethod
def add_soup(soup):
HotPot.soup = soup
@staticmethod
def add_main(protein):
HotPot.protein = protein
@staticmethod
def add_vegitables(vegitables):
HotPot.vegetables = vegitables
@staticmethod
def add_other_ingredients(other_ingredients):
HotPot.other_ingredients = other_ingredients
- Bereiten Sie eine Factory-Klasse vor, die den Prozess der Herstellung eines Topfes abstrahiert
class Factory(metaclass=ABCMeta):
@abstractmethod
def get_soup(self):
pass
@abstractmethod
def get_main(self):
pass
@abstractmethod
def get_vegetables(self):
pass
@abstractmethod
def get_other_ingredients(self):
pass
- Bereiten Sie die Mizutaki Factory-Klasse vor, die dies erbt, und stellen Sie darauf basierend einen Wasserkocher her.
class MizutakiFactory(Factory):
def get_soup(self):
return "torigara"
def get_main(self):
return "chicken"
def get_vegetables(self):
return ["hakusai", "ninjin", "negi"]
def get_other_ingredients(self):
return ["tofu"]
class Sample:
@staticmethod
def main():
hp = HotPot()
mf = MizutakiFactory()
hp.add_soup(mf.get_main())
hp.add_main(mf.get_main())
hp.add_vegitables(mf.get_vegetables())
hp.add_other_ingredients(mf.get_other_ingredients())
--Wählen Sie die Factory-Klasse aus, die tatsächlich verwendet werden soll, und generieren Sie sie gemäß der im Argument angegebenen Zeichenfolge
class Sample:
@staticmethod
def create_factory(s):
if s == "Kimchi Hot Pot":
return KimuchiFactory()
elif s == "Sukiyaki":
return SukiyakiFactory()
else:
return MizutakiFactory()
@staticmethod
def main(arg):
hp = HotPot()
fc = create_factory(arg)
hp.add_soup(fc.get_main())
hp.add_main(fc.get_main())
hp.add_vegitables(fc.get_vegetables())
hp.add_other_ingredients(fc.get_other_ingredients())
- Bei der Hauptmethode wird die Verarbeitung fortgesetzt, ohne den tatsächlichen Typ der Factory-Methode zu kennen. Mit anderen Worten, wir fahren mit der Verarbeitung mit der abstrakten Factory-Klasse fort. ――Es ist möglich, auf die Anfrage zu antworten, "die zu verwendenden Objekte sanft zu ersetzen".
Zusammenfassung der Builder-Muster
Brückenmuster
- Funktionen und Implementierungen können getrennt und unabhängig voneinander erweitert werden. --Beispiel
- Angenommen, eine Klasse MyClassA mit einer Methode namens methodA wird von zwei Klassen geerbt, MyClassASub1 und MyClassASub2, die unterschiedliche Implementierungen der methodA-Methode haben.
- Angenommen, Sie haben eine Klasse namens MyClassB erstellt, die von MyClassA erbt, um MyClassA eine Methode namens methodB hinzuzufügen.
- Wenn Sie für MyClassB dieselbe Implementierung wie die in MyClassASub1 und MyClassASub2 implementierte Methode A verwenden möchten, müssen Sie Klassen wie MyClassBSub1 und MyClassBSub2 erstellen, die von der MyClassB-Klasse erben. ← ** Problematisch ** ―― Je größer der Maßstab, desto schwieriger wird das Spiel.
Eigentlich verwenden
Gegenstand
- Denken Sie an die abstrakte Klasse Sorter mit Sortierfunktion und an die Klassen (QuickSorter-Klasse, BubbleSorter-Klasse), die die sort-Methode (Object obj []) implementieren, die in dieser Sorter-Klasse als abstrakte Methode definiert ist.
- Der Code für die Sorter-Klasse, die QuickSorter-Klasse und die BubbleSorter-Klasse lautet wie folgt. Die Implementierung des Sortierteils wird hier weggelassen, da dies nicht wichtig ist.
# -*- coding:utf-8 -*-
from abc import ABCMeta, abstractmethod
class Sorter(metaclass=ABCMeta)
@abstractmethod
def sort(self, obj):
pass
class QuickSorter(Sorter):
def sort(self, obj):
#Schnelle Sorte
pass
class BubbleSorter(Sorter):
def sort(self, obj):
#Blasensorte
pass
- Ich möchte eine timer_sorter-Methode hinzufügen, die eine Funktion zum Anzeigen der zum Sortieren benötigten Zeit für die Sorter-Klasse hat.
from datetime import datetime
class TimerSorter(metaclass=ABCMeta, Sorter):
@abstractmethod
def time_sorter(self, obj):
start = datetime.now()
Sorter.sort(obj)
end = datetime.now()
print("time:" + str((end - start)))
- Bei dieser Rate kann der TimerSorter-Klasse keine Implementierung zugewiesen werden.
- Um es zu implementieren, muss eine Klasse vorbereitet werden, die QuickSorter / BubbleSorter entspricht.
- Denk an das Brückenmuster. Entwerfen Sie die Methode, die zur Implementierung an die Klassenhierarchie delegiert werden soll, für die Methode, deren Implementierung geändert werden kann.
- Klassenhierarchie für die Implementierung: Betrachten Sie hier die Klassenhierarchie, deren übergeordnetes Element die SortImple-Klasse ist, als Klassenhierarchie, die die Implementierung der Sortiermethode angibt.
class SortImple(metaclass=ABCMeta):
@abstractmethod
def sort(self, obj):
pass
class Sorter:
si = SortImple()
@staticmethod
def sorter(si):
Sorter.si = si
def sort(self, obj):
Sorter.si.sort(obj)
class QuickSorterImple(SortImple):
def sort(self, obj):
#Schnelle Sorte
pass
class BubbleSorterImple(SortImple):
def sort(self, obj):
#Blasensorte
pass
- Auf diese Weise kann auch eine neue Klasse, die durch Erweitern der Sorter-Klasse erstellt wurde, den vorhandenen Implementierungsteil verwenden, um Funktionen hinzuzufügen. Um beispielsweise eine TimerSorter-Klasse zu erstellen, die die Sorter-Klasse erweitert, sieht es folgendermaßen aus.
from datetime import datetime
class TimerSorter(metaclass=ABCMeta, Sorter):
def __init__(self, sort_impl):
super(sort_impl)
@abstractmethod
def time_sorter(self, obj):
start = datetime.now()
Sorter.sort(obj)
end = datetime.now()
print("time:" + str((end - start)))
- Durch Trennen der Klassenhierarchie zum Erweitern der Funktion und der Klassenhierarchie zum Erweitern der Implementierung können Sie die Implementierungshierarchieklasse und die Erweiterungsklasse in einer beliebigen Kombination verwenden.
- In diesem Beispiel dienen die Klassen Sorter und SortImple als Brücke zwischen der Hierarchie der Erweiterungsklassen und der Hierarchie der Implementierungserweiterungsklassen.
Zusammenfassung der Builder-Muster
Strategiemuster
――Bei normaler Programmierung kann der Algorithmus in einer Form implementiert werden, die sich in die Methode einfügt.
- Ändern Sie den Algorithmus, indem Sie mit der if-Anweisung usw. verzweigen.
- Beachten Sie im Strategiemuster den Strategieteil und erstellen Sie ihn als separate Klasse. --Erstellen Sie den Teil Strategie x als separate Klasse. Wenn Sie die Strategie ändern möchten, ändern Sie die zu verwendende Strategieklasse.
- Durch die Verwendung des Strategiemusters ist das Design flexibler und einfacher zu warten als der Algorithmus, der sich in die Methode einfügt.
Eigentlich verwenden
Gegenstand
――Es gibt viele Fälle, in denen Sie den Algorithmus je nach Situation ändern müssen. Beispielsweise wird in einem Spielprogramm der Strategiealgorithmus abhängig vom Schwierigkeitsgrad geändert. ――Hier wollen wir uns einen Algorithmus überlegen, der einen einfachen Vergleich zwischen groß und klein ermöglicht.
- Erstellen Sie zunächst eine menschliche Klasse, die Menschen repräsentiert. Die menschliche Klasse muss vier Parameter haben: Name, Größe, Gewicht und Alter.
# -*- coding:utf-8 -*-
from abc import ABCMeta, abstractmethod
class Human:
def __init__(self, name, height, weight, age):
self.name = name
self.height = height
self.weight = weight
self.age = age
- Betrachten Sie hier eine Klasse namens SampleClass, die die Größe von zwei angegebenen menschlichen Instanzen vergleicht.
class SampleClass:
@staticmethod
def compare(h1: Human, h2: Human) -> int:
if h1.age > h2.age:
return 1
elif h1.age == h2.age:
return 0
else:
return -1
- Hier denke ich nur daran, das Alter zu vergleichen und die Ergebnisse zurückzugeben. --Aber menschliche Objekte haben mehrere Parameter und es gibt verschiedene Möglichkeiten, Menschen zu vergleichen. ――Das Vergleichsergebnis hängt davon ab, welcher Parameter wie verwendet wird. ――Bei einem Vergleich nur nach Alter und nach Größe werden unterschiedliche Ergebnisse erzielt.
- Stellen Sie sich daher ein Programm vor, mit dem Sie die zu vergleichenden Parameter angeben können.
class SampleClass2:
type = -1
COMPARE_AGE = 1
COMPARE_HEIGHT = 2
COMPARE_WEIGHT = 3
def __init__(self, type):
SampleClass2.type = type
@staticmethod
def compare(h1: Human, h2: Human) -> int:
if SampleClass2.type == SampleClass2.COMPARE_AGE:
if h1.age > h2.age:
return 1
elif h1.age == h2.age:
return 0
else:
return -1
elif SampleClass2.type == SampleClass2.COMPARE_HEIGHT:
if h1.height > h2.height:
return 1
elif h1.height == h2.height:
return 0
else:
return -1
#・ ・ ・
――Es wird komplizierter Code. Im Strategiemuster wird der Teil des Algorithmus, der je nach Situation geändert werden muss, bewusst als separate Klasse getrennt, um die Aussicht auf Änderung oder Hinzufügung des Algorithmus zu verbessern.
- Trennen Sie zunächst den Teil des Vergleichsalgorithmus als Klasse. Erstellen Sie beispielsweise eine AgeComparator-Klasse, um das Alter zu vergleichen.
class AgeComparator:
@staticmethod
def compare(h1: Human, h2: Human) -> int:
if h1.age > h2.age:
return 1
elif h1.age == h2.age:
return 0
else:
return -1
- Trennen Sie den Vergleichsalgorithmus-Teil, damit der eigentliche Vergleichsprozess an AgeComparator delegiert werden kann.
class MyClass:
@staticmethod
def compare(h1: Human, h2: Human) -> int:
return AgeComparator.compare(h1, h2)
――Das allein hat keinen Wert und ist kein Strategiemuster. Das Strategiemuster erfordert, dass separate Algorithmus-Teile eine gemeinsame Schnittstelle haben.
- Das heißt, mehrere als Algorithmus getrennte Klassen müssen eine gemeinsame Schnittstelle haben.
- Im Beispielfall können zusätzlich zur AgeComparator-Klasse zum Vergleichen des Alters die HeightComparator-Klasse zum Vergleichen von Höhen und die WeightComparator-Klasse zum Vergleichen von Gewichten berücksichtigt werden.
- Geben Sie den Klassen, die diese Vergleichsalgorithmen darstellen, eine gemeinsame Schnittstelle.
- Hier definieren wir die Composer-Oberfläche.
class Comparator(metaclass=ABCMeta):
@staticmethod
@abstractmethod
def compare(h1: Human, h2: Human) -> int:
pass
class AgeComparator(Comparator):
@staticmethod
def compare(h1: Human, h2: Human) -> int:
if h1.age > h2.age:
return 1
elif h1.age == h2.age:
return 0
else:
return -1
class HeightComparator(Comparator):
@staticmethod
def compare(h1: Human, h2: Human) -> int:
if h1.height > h2.height:
return 1
elif h1.height == h2.height:
return 0
else:
return -1
- Auf diese Weise kann SampleClass wie folgt umgeschrieben werden.
class SampleClass:
def __init__(self, comp: Comparator):
self._comp = comp
def compare(self, h1: Human, h2: Human) -> int:
return self._comp.compare(h1, h2)
Zusammenfassung der Strategiemuster
Recommended Posts