Vitajte na [www.pocitac.win] Pripojiť k domovskej stránke Obľúbené stránky
1. Singleton
* Účel: Zabezpečuje, aby sa vytvorila iba jedna inštancia triedy a poskytuje globálny prístup prístupu k tejto inštancii.
* Kedy použiť: Ak potrebujete jeden zdieľaný prostriedok (napr. Správca konfigurácie, databázový spoj, logger).
* jednoduchý príklad (python):
`` `Python
trieda Singleton:
_instance =žiadny
def __new __ (Cls, *args, ** kwargs):
ak nie Cl._instance:
cls._instance =super (singleton, cls) .__ nový __ (cls, *args, ** kwargs)
# Ak je to potrebné, inicializujte inštanciu tu
návrat cls._instance
# Použitie
inštancia1 =singleton ()
instance2 =singleton ()
tlač (instance1 je instance2) # výstup:true (sú to rovnaký objekt)
`` `
* Poznámky: Buďte opatrní s Singletónmi v silne viacnásobných prostrediach. Možno budete musieť pridať blokovacie mechanizmy, aby ste zaistili bezpečnosť vlákna počas tvorby inštancie. Nadmerné používanie singletonov môže viesť k tesnému spojeniu a sťažnosti testovania.
2. Továreň
* Účel: Definuje rozhranie na vytvorenie objektu, ale umožňuje podtriedy rozhodnúť sa, ktorá trieda má inštanciu. Oddeľuje kód klienta z vytvorenej konkrétnej triedy.
* Kedy použiť: Ak potrebujete vytvárať objekty rôznych typov na základe určitého stavu alebo konfigurácie a chcete sa vyhnúť tvrdému kódovaniu logiky vytvárania objektu priamo v kóde klienta.
* jednoduchý príklad (python):
`` `Python
tlačidlo triedy:
def vykreslenie (self):
Zvýšte notiMplementedError ()
trieda HtmlButton (tlačidlo):
def vykreslenie (self):
Vráťte sa "
trieda WindowsButton (tlačidlo):
def vykreslenie (self):
Vráťte „tlačidlo Windows (špecifické pre používateľské rozhranie)“
triedu ButtonFactory:
def create_button (self, button_type):
if button_type =="html":
návrat htmlButton ()
ELIF Button_type =="Windows":
návrat WindowsButton ()
inak:
Zvýšte ValueError („Typ neplatného tlačidla“)
# Použitie
Factory =ButtonFactory ()
HTML_BUTTON =Factory.create_button ("HTML")
Windows_button =Factory.create_button ("Windows")
tlač (html_button.render ()) # výstup:
`` `
* Poznámky: Továreň vám umožňuje pridať nové typy tlačidiel bez toho, aby ste priamo upravili triedu „ButtonFactory“ (otvorený/zatvorený princíp).
3. Stratégia
* Účel: Definuje rodinu algoritmov, zapuzdruje každú z nich a robí ich zameniteľnými. Stratégia umožňuje, aby sa algoritmus líšil nezávisle od klientov, ktorí ho používajú.
* Kedy použiť: Ak máte viac spôsobov, ako vykonať konkrétnu úlohu a chcete medzi nimi ľahko prepínať za behu.
* jednoduchý príklad (python):
`` `Python
Platby triedy:
def Pay (ja, suma):
Zvýšte notiMplementedError ()
Trieda CreditCardPayment (PaymentsTrategy):
def __init __ (self, card_number, expiry_date, cvv):
self.card_number =card_number
self.expiry_date =expiry_date
self.cvv =cvv
def Pay (ja, suma):
Print (F "Platba $ {sum} pomocou kreditnej karty:{self.card_number}")
Class PayPalPayment (PaymentsTrategy):
def __init __ (ja, e -mail):
self.email =e -mail
def Pay (ja, suma):
Print (f "Platba $ {sum} pomocou PayPal:{self.email}")
Class ShoppingCart:
def __init __ (ja, platba_strategy:PlatbyStrategy):# Stratégia tu vstrekuje
self.Payment_strategy =platba_strategy
self.total =0
def add_item (ja, cena):
self.total +=cena
DEF pokladňa (self):
self.payment_strategy.pay (self.total)
# Použitie
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 () # Výstup:Platba 150 dolárov pomocou kreditnej karty:1234-5678-9012-3456
CART2 =ShoppingCart (PayPal)
cart2.add_item (200)
cart2.Checkout () # výstup:Platba 200 dolárov pomocou paypal:[email protected]
`` `
* Poznámky: „ShoppingCart“ nepotrebuje poznať konkrétny spôsob platby. Na vykonanie platby jednoducho používa injektované „platby“. To uľahčuje pridávanie nových spôsobov platby bez úpravy triedy „ShoppingCart“.
4. Pozorovateľ
* Účel: Definuje závislosť medzi jednotlivými objektmi, takže keď sa jeden objekt zmení, všetky jeho závislé osoby sú automaticky upozornené a aktualizované.
* Kedy použiť: Ak zmena v jednom objekte vyžaduje zmenu iných objektov a nechcete, aby boli objekty pevne spojené. Príklady:Manipulácia s udalosťami, aktualizácie používateľského rozhrania, architektúra modelu-View-Controller (MVC).
* jednoduchý príklad (python):
`` `Python
Predmet triedy:
def __init __ (self):
self._observers =[]
def Atter (Self, Observer):
self._observers.append (pozorovateľ)
Def Detach (Self, Observer):
self._observers.Remove (Observer)
def Intetify (Self, správa):
Pre pozorovateľa v self._observers:
Observer.update (správa)
pozorovateľ triedy:
DEF UPDATE (Self, správa):
Zvýšte notiMplementedError ()
trieda ConcreteObservera (pozorovateľ):
DEF UPDATE (Self, správa):
tlač (F "Observer A prijatý:{Message}")
Trieda ConcreteObserverb (Observer):
DEF UPDATE (Self, správa):
print (f "Prijaté pozorovateľ B:{Message.upper ()}")
# Použitie
subjekt =subjekt ()
Observer_a =concreteObservera ()
Observer_b =concreteObserverb ()
subjekt.Attach (Observer_a)
subjekt.Attach (Observer_b)
subjekt.Notify („Dobrý deň, svet!“) # Výstup:pozorovateľ prijatý:Dobrý deň, svet!
# Observer B Prijaté:Dobrý deň, svet!
subjekt.detach (pozorovateľ_a)
subjekt.Notify („Zbohom!“) # výstup:Observer B Prijaté:Zbohom!
`` `
* Poznámky: „Subjekt“ udržiava zoznam „pozorovateľov“. Keď sa stav „subjektu“ zmení (v tomto prípade, keď sa nazýva `notify`), iteruje sa prostredníctvom zoznamu a volá metódu„ aktualizácie “na každom` Observer`.
5. Metóda šablóny
* Účel: Definuje kostru algoritmu v základnej triede, ale umožňuje podtriedy potlačiť konkrétne kroky algoritmu bez zmeny jeho štruktúry.
* Kedy použiť: Ak máte súbor krokov, ktoré je potrebné vykonať v konkrétnom poradí, ale niektoré z týchto krokov sa môžu líšiť v závislosti od konkrétnej implementácie.
* jednoduchý príklad (python):
`` `Python
Dataprocesor triedy:
def process_data (self):
self.read_data ()
self.Validate_data ()
self.transform_data ()
self.save_data ()
tlač („Kompletné spracovanie údajov“)
def read_data (self):
Zvýšte notiMplementedError ()
def validate_data (self):
tlač („Predvolená validácia:Kontrola hodnôt nulových hodnôt.“)
def transformácia_data (self):
Zvýšte notiMplementedError ()
def Save_data (self):
Zvýšte notiMplementedError ()
Trieda CSVDataprocesor (Dataprocesor):
def read_data (self):
Tlač („Čítanie údajov zo súboru CSV“)
def transformácia_data (self):
tlač ("Transformácia údajov CSV.")
def Save_data (self):
tlač („Uloženie údajov do databázy.“)
Trieda JSondataprocesor (Dataprocesor):
def read_data (self):
Tlač („Čítanie údajov zo súboru JSON.“)
def validate_data (self):
Print („Vlastná validácia pre údaje JSON:Schéma kontroly.“)
def transformácia_data (self):
tlač ("Transformácia údajov JSON.")
def Save_data (self):
tlač („Uloženie údajov do súboru JSON.“)
# Použitie
csv_procesor =csvdataprocesor ()
csv_procesor.process_data ()
# Výstup:
# Čítanie údajov zo súboru CSV.
# Predvolená validácia:Kontrola hodnôt nulových hodnôt.
# Transformácia údajov CSV.
# Ukladanie údajov do databázy.
# Úplné spracovanie údajov.
json_procesor =jSondataprocesor ()
json_procesor.process_data ()
# Výstup:
# Čítanie údajov zo súboru JSON.
# Vlastná validácia pre údaje JSON:Schéma kontroly.
# Transformácia údajov JSON.
# Uloženie údajov do súboru JSON.
# Úplné spracovanie údajov.
`` `
* Poznámky: „Dataprocesor“ definuje celkovú štruktúru algoritmu spracovania údajov. Podtriedy ako `csvdataprocesor` a` jSondataprocesor` poskytujú konkrétne implementácie pre kroky `read_data`,` transform_data` a `Save_data` kroky. Krok `overate_data` môže byť prepísaný alebo použiť predvolenú implementáciu.
6. Dekorátor
* Účel: Dynamicky pridáva zodpovednosti k objektu bez úpravy jeho triedy. Dekorátori poskytujú flexibilnú alternatívu k podtriede pre rozšírenie funkčnosti.
* Kedy použiť: Ak chcete pridať funkčnosť k objektu za behu, bez ovplyvnenia iných objektov rovnakej triedy. Užitočné na pridávanie protokolovania, ukladania do vyrovnávacej pamäte alebo autorizácie.
* jednoduchý príklad (python):
`` `Python
Káva triedy:
def get_cost (self):
návrat 5
def get_description (self):
Vráťte „káva“
triedu Coffeedecorator:
def __init __ (ja, káva):
self._coffee =káva
def get_cost (self):
return self._coffee.get_cost ()
def get_description (self):
return self._coffee.get_description ()
Trieda Milkdecorator (Coffeedecorator):
def get_cost (self):
return self._coffee.get_cost () + 2
def get_description (self):
návrat self._coffee.get_description () + ", mlieko"
Trieda SugardeCorator (Coffeedecorator):
def get_cost (self):
return self._coffee.get_cost () + 1
def get_description (self):
návrat self._coffee.get_description () + ", cukor"
# Použitie
káva =káva ()
Print (f "{Coffe.get_description ()} - Cena:$ {Coffee.get_cost ()}") # Výstup:káva - Cena:5 $ 5 $
Milk_coffee =MilkdeCorator (káva)
Print (f "{mlieko_coffee.get_description ()} - Cena:$ {mlieko_coffee.get_cost ()}") # výstup:káva, mlieko - cena:7 $
Sugar_milk_coffee =SugarDecorator (mlieko_coffee)
Print (f "{Sugar_milk_coffee.get_description ()} - Cena:$ {Sugar_milk_coffee.get_cost ()}") # výstup:káva, mlieko, cukor - Cena:$ 8 $ 8
`` `
* Poznámky: „Coffeedecorator“ poskytuje základnú triedu pre dekoratorov. Každý dekoratér (napr. „MilkDecorator`,` SugardeCorator`) zabalí originálny objekt `kávu a pridáva svoju vlastnú funkčnosť (v tomto prípade pridanie nákladov a popis).
Kľúčové úvahy o výbere vzoru:
* Pochopte problém: Jasne definujte problém, ktorý sa snažíte vyriešiť pred dosiahnutím vzoru. Nepoužívajte vzory; Použite ich ako nástroje na vylepšenie kódu.
* jednoduchosť: Začnite s najjednoduchším riešením, ktoré vyhovuje vašim potrebám. Predčasne nekontrolujte veci.
* kontext: Najlepší vzorec závisí od konkrétneho kontextu vášho projektu, jazyka, ktorý používate, a existujúcej kódovej základne.
* Testovanie: Vzory dizajnu by mali urobiť váš kód testovateľný, nie menej. Uistite sa, že môžete ľahko písať testy jednotiek pre komponenty, ktoré používate.
Toto je len niekoľko príkladov jednoduchých vzorov dizajnu. Keď získate viac skúseností, naučíte sa rozpoznávať situácie, v ktorých je možné tieto a ďalšie vzory použiť na vytvorenie robustnejšieho, údržbnejšieho a opakovane použiteľného kódu. Veľa šťastia!