1. Singleton
* Scopo: Garantisce che venga creata una sola istanza di una classe e fornisce un punto di accesso globale a tale istanza.
* Quando usare: Quando è necessario una singola risorsa condivisa (ad es. Configuration Manager, pool di connessioni del database, logger).
* Esempio semplice (Python):
`` `Python
Singleton di classe:
_instance =nessuno
def __new __ (cls, *args, ** kwargs):
se non Cls._instance:
cs._instance =super (singleton, cls) .__ new __ (cls, *args, ** kwargs)
# Inizializza l'istanza qui se necessario
restituisce cs._instance
# Utilizzo
Instance1 =singleton ()
istanza2 =singleton ()
Print (Instance1 is Instance2) # output:true (sono lo stesso oggetto)
`` `
* Note: Fai attenzione ai singoli in ambienti pesantemente multithread. Potrebbe essere necessario aggiungere meccanismi di bloccaggio per garantire la sicurezza dei thread durante la creazione di istanza. L'uso eccessivo di singoli può portare a un accoppiamento stretto e rendere difficili i test.
2. Metodo di fabbrica
* Scopo: Definisce un'interfaccia per la creazione di un oggetto, ma consente di decidere quale classe istanziare. Discoupla il codice client dalla classe specifica creata.
* Quando usare: Quando è necessario creare oggetti di diversi tipi in base a alcune condizioni o configurazione e si desidera evitare di codificare la logica di creazione dell'oggetto direttamente nel codice client.
* Esempio semplice (Python):
`` `Python
Pulsante Classe:
def render (self):
sollevare notimplementderror ()
Classe htmlbutton (pulsante):
def render (self):
Restituisci "
Classe WindowsButton (pulsante):
def render (self):
Restituisci "Pulsante Windows (Interfaccia utente)
Classe ButtonFactory:
def create_button (self, bottl_type):
if Button_Type =="HTML":
return htmlbutton ()
Elif Button_Type =="Windows":
restituire WindowsButton ()
altro:
Aumenta ValueRror ("Tipo di pulsante non valido")
# Utilizzo
Factory =ButtonFactory ()
html_button =factory.create_button ("html")
Windows_Button =Factory.Create_Button ("Windows")
print (html_button.render ()) # output:
Stampa (Windows_Button.Render ()) # Output:pulsante Windows (interfaccia utente)
`` `
* Note: Il metodo di fabbrica consente di aggiungere nuovi tipi di pulsanti senza modificare direttamente la classe `BOCKFACTORY` (principio aperto/chiuso).
3. Strategia
* Scopo: Definisce una famiglia di algoritmi, incapsula ciascuno e li rende intercambiabili. La strategia consente all'algoritmo di variare indipendentemente dai clienti che lo utilizzano.
* Quando usare: Quando si dispone di più modi per eseguire un'attività specifica e si desidera essere in grado di spostarsi facilmente in fase di esecuzione.
* Esempio semplice (Python):
`` `Python
Classe Paymentstrategy:
Def Pay (Self, Importo):
sollevare notimplementderror ()
Class CreditCardPayment (Paymentstrategy):
def __init __ (self, card_number, espiry_date, cvv):
self.card_number =card_number
self.expiry_date =Escary_Date
self.cvv =cvv
Def Pay (Self, Importo):
print (f "pagando $ {importo} usando la carta di credito:{self.card_number}")
Classe PayPalPayment (Paymentstrategy):
def __init __ (self, email):
self.email =email
Def Pay (Self, Importo):
print (f "pagando $ {importo} usando paypal:{self.email}")
Class ShoppingCart:
def __init __ (self, payment_strategy:paymentstrategy):# strategia iniettata qui
self.payment_strategy =payment_strategy
self.total =0
def add_item (self, prezzo):
self.total +=prezzo
Def Checkout (Self):
self.payment_strategy.pay (self.total)
# Utilizzo
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 () # Output:pagamento di $ 150 utilizzando la carta di credito:1234-5678-9012-3456
CART2 =ShoppingCart (PayPal)
cart2.add_item (200)
CART2.Checkout () # Output:pagamento di $ 200 utilizzando PayPal:[email protected]
`` `
* Note: `Shoppingcart` non ha bisogno di conoscere il metodo di pagamento specifico. Utilizza semplicemente l'iniezione di `Paymentstrategy` per eseguire il pagamento. Ciò semplifica l'aggiunta di nuovi metodi di pagamento senza modificare la classe `shopping`.
4. Observer
* Scopo: Definisce una dipendenza da uno a molti oggetti in modo che quando un oggetto cambia indica, tutte le sue persone a carico vengono notificate e aggiornate automaticamente.
* Quando usare: Quando una modifica in un oggetto richiede di modificare altri oggetti e non si desidera che gli oggetti siano accoppiati strettamente. Esempi:gestione degli eventi, aggiornamenti dell'interfaccia utente, architettura Model-View-Controller (MVC).
* Esempio semplice (Python):
`` `Python
Oggetto di classe:
def __init __ (self):
self._observers =[]
def collega (self, osservatore):
self._observers.append (Observer)
def detach (self, osservatore):
self._observers.remove (Observer)
def notify (self, messaggio):
per Observer in self._observers:
Observer.Update (messaggio)
Classe Observer:
DEF Update (Self, Message):
sollevare notimplementderror ()
Clice CencreteObservera (Observer):
DEF Update (Self, Message):
print (f "Observer A Riceving:{Message}")
Clice CencreteObserverb (Observer):
DEF Update (Self, Message):
print (f "Observer B ricevuto:{message.upper ()}")
# Utilizzo
soggetto =soggetto ()
Observer_A =concreteObservera ()
Observer_b =concreteObserverB ()
soggetto.Attach (Observer_A)
soggetto.Attach (Observer_B)
soggetto.notify ("ciao, mondo!") # output:osservatore a ricevuto:ciao, mondo!
# Observer B ha ricevuto:ciao, mondo!
soggetto.detach (Observer_A)
soggetto.notify ("Addio!") # Output:Observer B Ricevuto:Addio!
`` `
* Note: Il "soggetto" mantiene un elenco di "osservatori". Quando lo stato del "soggetto" cambia (in questo caso, quando viene chiamato `notify`), si itetera attraverso l'elenco e chiama il metodo` aggiornamento 'su ogni `osservatore'.
5. Metodo del modello
* Scopo: Definisce lo scheletro di un algoritmo in una classe di base, ma consente di sostituire i passaggi specifici dell'algoritmo senza cambiare la sua struttura.
* Quando usare: Quando si dispone di una serie di passaggi che devono essere eseguiti in un ordine specifico, ma alcuni di questi passaggi possono variare a seconda dell'implementazione specifica.
* Esempio semplice (Python):
`` `Python
Classe DataProcessor:
def processo_data (self):
self.read_data ()
self.validate_data ()
self.transform_data ()
self.save_data ()
Stampa ("Elaborazione dei dati completi")
def read_data (self):
sollevare notimplementderror ()
def validato_data (self):
Stampa ("Convalida predefinita:verifica dei valori null.")
def Transform_data (self):
sollevare notimplementderror ()
def salva_data (self):
sollevare notimplementderror ()
Classe csvdataprocessor (dataprocessor):
def read_data (self):
Stampa ("Lettura dei dati dal file CSV.")
def Transform_data (self):
Stampa ("Trasformare i dati CSV.")
def salva_data (self):
Stampa ("Salvare i dati nel database")
Classe jSondataprocessor (dataprocessor):
def read_data (self):
Stampa ("Lettura dei dati dal file JSON.")
def validato_data (self):
Print ("Convalida personalizzata per i dati JSON:Verifica dello schema.")
def Transform_data (self):
Stampa ("Transforming JSON Data.")
def salva_data (self):
Stampa ("Salvare i dati sul file JSON.")
# Utilizzo
csv_processor =csvdataprocessor ()
csv_processor.process_data ()
# Produzione:
# Lettura dei dati dal file CSV.
# Convalida predefinita:verifica dei valori null.
# Trasformare i dati CSV.
# Salvare i dati nel database.
# Elaborazione dei dati completa.
JSON_Processor =JSONDATAPROCESSOR ()
json_processor.process_data ()
# Produzione:
# Lettura dei dati dal file JSON.
# Convalida personalizzata per i dati JSON:controllo dello schema.
# Trasformare i dati JSON.
# Salvare i dati nel file JSON.
# Elaborazione dei dati completa.
`` `
* Note: Il `dataprocessor` definisce la struttura generale dell'algoritmo di elaborazione dei dati. Le sottoclassi come `csvdataprocessor` e` jsondataprocessor` forniscono implementazioni specifiche per i passaggi `read_data`,` trasform_data` e `save_data`. Il passaggio `validate_data` può essere sovrascritto o utilizzare l'implementazione predefinita.
6. Decoratore
* Scopo: Aggiunge dinamicamente le responsabilità a un oggetto senza modificare la sua classe. I decoratori offrono un'alternativa flessibile alla sottoclasse per estendere la funzionalità.
* Quando usare: Quando si desidera aggiungere funzionalità a un oggetto in fase di esecuzione, senza influire su altri oggetti della stessa classe. Utile per l'aggiunta di registrazione, memorizzazione nella cache o autorizzazione.
* Esempio semplice (Python):
`` `Python
Classe caffè:
def get_cost (self):
Ritorno 5
def get_description (self):
ritorna "caffè"
Classe CoffeedeCorator:
def __init __ (sé, caffè):
self._coffee =caffè
def get_cost (self):
return self._coffee.get_cost ()
def get_description (self):
return self._coffee.get_description ()
MilkDecorator di classe (CoffeedeCorator):
def get_cost (self):
restituisce self._coffee.get_cost () + 2
def get_description (self):
restituire self._coffee.get_description () + ", latte"
SugardeCorator di classe (CoffeedeCorator):
def get_cost (self):
restituisce self._coffee.get_cost () + 1
def get_description (self):
restituire self._coffee.get_description () + ", zucchero"
# Utilizzo
caffè =caffè ()
print (f "{caffè.get_description ()} - costo:$ {caffè.get_cost ()}") # output:caffè - costo:$ 5
Milk_Coffee =MilkDecorator (caffè)
print (f "{lattine_coffee.get_description ()} - Costo:$ {Milk_coffee.get_cost ()}") # Output:caffè, latte - Costo:$ 7
Sugar_Milk_Coffee =SugardeCorator (Milk_Coffee)
print (f "{Sugar_milk_coffee.get_description ()} - Costo:$ {Sugar_milk_coffee.get_cost ()}") # Output:caffè, latte, Sugar - Costo:$ 8
`` `
* Note: Il `CoffeedeCorator` fornisce una lezione di base per i decoratori. Ogni decoratore (ad es. `MilkDecorator`,` SugardeCorator`) avvolge l'oggetto originale `Coffee` e aggiunge la propria funzionalità (in questo caso, aggiungendo costi e descrizione).
Considerazioni chiave per la scelta di uno schema:
* Comprendi il problema: Definisci chiaramente il problema che stai cercando di risolvere prima di cercare uno schema. Non applicare ciecamente i modelli; Usali come strumenti per migliorare il tuo codice.
* semplicità: Inizia con la soluzione più semplice che soddisfa le tue esigenze. Non ingannare le cose prematuramente.
* Contesto: Il modello migliore dipende dal contesto specifico del progetto, dalla lingua che stai utilizzando e dalla base di codice esistente.
* Test: I modelli di progettazione dovrebbero rendere il tuo codice più verificabile, non inferiore. Assicurati di poter scrivere facilmente i test unitari per i componenti che stai utilizzando.
Questi sono solo alcuni esempi di semplici modelli di design. Man mano che acquisisci più esperienza, imparerai a riconoscere situazioni in cui questi e altri modelli possono essere applicati per creare codice più robusto, mantenibile e riutilizzabile. Buona fortuna!
Informazioni correlate
hardware © www.354353.com