I lettori come te aiutano a sostenere MUO. Quando effettui un acquisto utilizzando i link sul nostro sito, potremmo guadagnare una commissione di affiliazione.
Il modello di progettazione del metodo del modello consente di definire i passaggi di un algoritmo all'interno di un singolo metodo di una classe. Ciò consente di vincolare operazioni specifiche di un'applicazione a un singolo metodo.
Ogni passaggio dell'algoritmo definito dal metodo modello è un metodo interno. Tuttavia, il metodo template gestisce solo l'implementazione di alcuni dei suoi metodi interni. Le sottoclassi di solito implementano uno o più metodi interni del metodo template.
Una sottoclasse può implementare un metodo astratto, ma non può ridefinire l'algoritmo implementato da un metodo finale.
Come funziona il metodo del modello
Un tipico modello di metodo modello avrà la seguente struttura:
finalevuototemplateMetodo(){
abstractOperazione1();
abstractOperazione2();Operazione concreta1();
Operazione concreta2();
gancio();
}
La prima cosa importante da notare è che templateMethod() è final, quindi nessuna sottoclasse può sovrascrivere questo metodo. L'altra cosa importante da notare sono i tre tipi di metodi utilizzati dal pattern del metodo del modello: concreto, astratto e hook.
La classe astratta che ospita il metodo template implementa tutti i suoi metodi concreti, mentre le sottoclassi concrete implementano i suoi metodi astratti. Il metodo hook di solito non fa nulla per impostazione predefinita, ma una sottoclasse ha la capacità di sovrascrivere questi metodi quando necessario.
Implementazione del modello del metodo modello in Java
Il pattern del metodo template funge da framework per un'applicazione. Quindi, vedrai spesso questo modello nei framework software che forniscono il progetto per lo sviluppo dell'applicazione.
Ad esempio, puoi connettere la tua applicazione a uno dei tanti sistemi di database. I passaggi per connettersi e utilizzare un database seguono un modello simile:
pubblicoastrattoclasseBanca dati{
// metodo modello
finalevuotodatabaseModello(){
// metodi astratti
setDBDriver();
setCredentials();// metodo concreto
Collegare();// metodi astratti
creaDB();
setDati();
leggiDati();// metodi hook
if (userWantsToUpdate()) {
aggiornaDati();
}if (userWantsToDelete()) {
cancellaDati();
}// metodo concreto
closeConnection();
}astrattovuotosetDBDriver();
astrattovuotosetCredentials();
astrattovuotocreateDB();
astrattovuotosetData();
astrattovuotoreadData();
astrattovuotoupdateData();
astrattovuotodeleteData();vuotoCollegare(){
System.out.println("Connessione al database...");
}vuotochiudiConnessione(){
System.out.println("Distruggi la connessione al database...");
}booleanouserWantsToUpdate(){
ritornofalso;
}
booleanouserWantsToDelete(){
ritornofalso;
}
}
Questa classe Database di esempio usa il pattern del metodo template per creare un modello che puoi usare con qualsiasi database. Per utilizzare un database, la tua applicazione dovrà connettersi ad esso, quindi distruggere la connessione dopo l'uso. Queste attività sono in genere le stesse per tutti i database. Pertanto, la classe Database astratta può implementare il Collegare() E chiudiConnessione() metodi.
Gli altri metodi nel metodo modello differiranno in base al tipo di database. Ad esempio, un database MySQL memorizza i dati nelle tabelle, mentre a Il database MongoDB memorizza i dati nelle raccolte. Se vuoi usare un Database MySQL in Java, crea semplicemente una nuova classe MySQL che estenda la classe Database:
pubblicoclasseMySQLestendeBanca dati{
@Oltrepassare
vuotosetDBDriver(){
System.out.println("Selezione del driver MySQL...");
}@Oltrepassare
vuotosetCredentials(){
System.out.println("Impostazione delle credenziali del database MySQL...");
}@Oltrepassare
vuotocreateDB(){
System.out.println("Creazione di una nuova tabella...");
}@Oltrepassare
vuotosetData(){
System.out.println("Inserimento dati nel database...");
}@Oltrepassare
vuotoreadData(){
System.out.println("Recupero dati dal database...");
}@Oltrepassare
vuotoupdateData(){
System.out.println("Aggiornamento dati nel database...");
}
@Oltrepassare
vuotodeleteData(){
System.out.println("Eliminazione dati dal database...");
}
}
La classe MySQL implementa tutti i metodi astratti della classe Database. Può anche eseguire l'override di alcuni metodi concreti. Tuttavia, non può toccare il databaseModello() metodo, che utilizza la parola chiave final.
pubblicoclassePrincipale{
pubblicostaticovuotoprincipale(Stringa[] argomenti){
Database mySQLDB = nuovo MySQL();
mySQLDB.databaseTemplate();
}
}
Questa classe Main crea un nuovo oggetto database MySQL e utilizza il metodo template per simulare il modo in cui un'applicazione si connetterebbe al database. L'esecuzione del metodo main stampa il seguente output sulla console:
Nell'output, noterai che l'applicazione non chiama mai il aggiornaDati() E cancella dati() metodi. Questo è il motivo per cui i metodi hook sono importanti. In un database SQL, ti consigliamo di creare nuove tabelle, inserire dati e visualizzare i tuoi dati. Tuttavia, potresti non voler aggiornare o eliminare i dati. Pertanto, i metodi hook danno alle sottoclassi la possibilità di controllare questi aspetti critici dell'algoritmo.
@Oltrepassare
booleanouserWantsToUpdate(){
ritornoVERO;
}Aggiungendo semplicemente il codice sopra alla classe MySQL, l'applicazione ora aggiorna i dati nel database. Se esegui nuovamente la classe Main, verrà visualizzato il seguente output aggiornato:
Come puoi vedere, l'applicazione sta ora aggiornando i dati nel database.
I vantaggi dell'utilizzo del modello di progettazione del metodo modello
Uno dei principali vantaggi del modello del metodo modello è che promuove la riusabilità del software. Questo modello di progettazione supporta anche una programmazione efficiente. Una sottoclasse deve solo implementare metodi che sono univoci per il suo funzionamento.
Inoltre, un'applicazione che utilizza il pattern del metodo template è più sicura, poiché le classi esterne non possono alterarne la struttura operativa.