Al momento sto studiando modelli di design tratti dal libro (che, sebbene non abbia provato nient'altro, trovo eccellenti) Head First Design Patterns.
Sono confuso su due concetti: il metodo di fabbrica e il modello di progettazione del metodo di fabbrica .
Stavo cercando di capire cosa significa ognuno, e sono arrivato a una conclusione. Mi piacerebbe sapere se le mie definizioni sono esatte.
Il metodo Factory è un metodo che ha lo scopo di fare una cosa: creare un oggetto di un supertipo specifico e restituirlo. Può o non può prendere un parametro e può o meno decidere di usare le istruzioni if quale tipo di oggetto concreto creare.
Ad esempio, questo è un metodo factory:
public Hat createHat(String hatColor){
Hat hat;
if (hatColor.equals("red")) hat = new RedHat();
else if (hatColor.equals("blue")) hat = new BlueHat();
else if (hatColor.equals("green")) hat = new GreenHat();
else hat = new DefaultHat();
return hat;
}
Il metodo di fabbrica Modello di progettazione è denominato il metodo di fabbrica.
Questo modello fornisce un modo specifico per incapsulare la creazione dell'oggetto dal client.
Funziona in questo modo: il pattern è un sistema di due classi, Creator e ConcreteCreator . Il Creatore è una classe abstract e ConcreteCreator è una sottoclasse di tale classe.
Il lavoro di ConcreteCreator : crea un oggetto e restituiscilo utilizzando un metodo factory . Deve solo contenere questo metodo.
Il lavoro del Creatore - manipola e usa l'oggetto ricevuto dalla sua sottoclasse, il ConcreteCreator, e di solito lo restituisce al client.
È fatto così:
Il Creatore contiene un metodo abstract , la sua firma è qualcosa come SupertypeObject createObject() . Ogni volta che ha bisogno di un oggetto di tipo SupertypeObject , chiama createObject() .
Il fatto è che createObject() è come ho detto abstract . È compito del ConcreteCreator implementare questo metodo.
In questo modo, l'implementazione di createObject() è nascosta dal Creatore. Non sa cosa ottiene l'oggetto concreto , ma sa per certo che è di tipo SypertypeObject .
In questo modo, un client può usare l'oggetto Creator per creare oggetti di qualche supertipo, ma gli oggetti concreti creati dipenderanno dalla sottoclasse. Così dichiarando ShoeFactory factory = new CaliforniaStyleShoesFactory() , la factory produrrà scarpe in stile california, mentre ShoeFactory factory = new NYStyleShoesFactory() farà sì che factory generi scarpe stile NY. Poiché l'implementazione della creazione degli oggetti concreti dipende da ConcreteCreator.
Codice da dimostrare:
Class Client(){
public static void main(String[] args){
ShoeFactory factory;
Shoe shoe;
factory = new NYStyleShoeFactory();
shoe = factory.makeShoe();
System.out.println(shoe.getDescription()); // "A NY style shoe".
// ShoeFactory's makeShoe() invokes createShoe() in the subclass, receives a Shoe
// (doesn't know the concrete type of the Shoe. Depends on the subclass) and
// does manipulations on it.
// Returns the Shoe to the client.
factory = new CaliforniaStyleShoeFactory():
shoe = factory.makeShoe();
System.out.println(shoe.getDescription()); // "A California style shoe".
}
}
La mia comprensione dei due concetti è accurata? Grazie
