Factory method: differenze tra le versioni
Contenuto cancellato Contenuto aggiunto
m r2.7.2) (Bot: Aggiungo fa:الگوی متد کارخانه شی |
completamento pagina, rimozione stub |
||
Riga 1:
[[File:FactoryMethod.svg|thumb|right|300px|Schema logico del Factory method in [[Unified Modeling Language|UML]]]]
[[
La creazione di un oggetto può, spesso, richiedere processi complessi la cui collocazione all'interno della classe di composizione potrebbe non essere appropriata. Esso può, inoltre, comportare la duplicazione di codice, richiedere informazioni non accessibili alla classe di composizione, o non provvedere un sufficiente livello di [[astrazione (informatica)|astrazione]]. Il factory method indirizza questi problemi definendo un [[metodo (informatica)|metodo]] separato per la creazione degli oggetti; tale metodo può essere ridefinito dalle sottoclassi per definire il tipo derivato di prodotto che verrà effettivamente creato.
== Applicabilità ==
Il pattern factory può essere utilizzato quando:
* La creazione di un oggetto preclude il suo riuso senza una significativa duplicazione di codice.
* La creazione di un oggetto richiede l'accesso ad informazioni o risorse che non dovrebbero essere contenuto nella classe di composizione.
* La gestione del ciclo di vita degli oggetti gestiti deve essere centralizzata in modo da assicurare un comportamento consistente all'interno dell'applicazione.
I metodi di factory sono spesso utilizzati in [[toolkit]] e [[framework]], dove il codice delle librerie necessita di poter creare oggetti il cui tipo è implementato nelle sottoclassi delle applicazioni che utilizzano il framework. Essi sono, inoltre, utilizzati nel [[Test Driven Development]] per porre le classi sotto test.<ref>{{cite book
|author=[[Michael Feathers|Feathers, Michael]]
|isbn=978-0-13-117705-5
|title=Working Effectively with Legacy Code
|date=October 2004
|publisher=Prentice Hall Professional Technical Reference
|___location=Upper Saddle River, NJ
}}</ref> Se una classe <code>Pippo</code> crea un oggetto <code>Pluto</code> che non può essere posto sotto una suite automatica di [[unit testing]] (ad esempio perché non può accedere ad una risorsa di produzione cui ha bisogno, come una base dati), allora la creazione dell'oggetto <code>Paperino</code> è posta nella [[funzione virtuale]] del factory <code>createPaperino</code> nella class <code>Pippo</code>. Per il test, <code>TestPippo</code> (una sottoclasse di <code>Pippo</code>) può essere creata, con il metodo <code>createPaperino</code> ridefinito per creare e ritornare un oggetto di <code>FakePaperino</code>, un oggetto di mock-up. Gli unit test possono, quindi, usare <code>TestPippo</code> per testare le funzionalità di <code>Pippo</code> senza incorrere negli effetti collaterali dati dall'uso dell'oggetto reale <code>Paperino</code>.
== Esempi di implementazione ==
=== Java ===
Un gioco del labirinto può essere giocato in due modi, uno con stanze regolari che sono connesse solo a quelle adiacenti e uno con stanze magiche che possono trasportare i giocatori in stanza casuali lungo di tutto il labirinto (questo esempio in [[Java (linguaggio)|Java]] è simile a quello presente sul libro ''[[Design Patterns]]''). Il gioco regolare può usare un modello del tipo:
<source lang=Java>
public class MazeGame {
public MazeGame() {
Room room1 = makeRoom();
Room room2 = makeRoom();
room1.connect(room2);
this.addRoom(room1);
this.addRoom(room2);
}
protected Room makeRoom() {
return new OrdinaryRoom();
}
}
</source>
Nel codice summenzionato, il costruttore <code>MazeGame</code> è un template che fornisce della logica comune e fa riferimento al metodo factory <code>makeRoom</code> che incapsula la logica di creazione delle stanza in modo che le stanze possano essere utilizzate nelle sottoclassi. Per implementare l'altra modalità di gioco, infatti, è necessario solo ridefinire <code>makeRoom</code> per l'implementazione delle stanze magiche:
<source lang=Java>
public class MagicMazeGame extends MazeGame {
@Override
protected Room makeRoom() {
return new MagicRoom();
}
}
</source>
=== PHP ===
Un esempio in [[PHP]] è qui riportato:
<source lang=PHP>
class Factory
{
public static function build($type)
{
$class = 'Format' . $type;
if (!class_exists($class)) {
throw new Exception('Missing format class.');
}
return new $class;
}
}
class FormatString {}
class FormatNumber {}
try {
$string = Factory::build('String');
}
catch (Exception $e) {
echo $e->getMessage();
}
try {
$number = Factory::build('Number');
}
catch (Exception $e) {
echo $e->getMessage();
}
</source>
==Limitazioni==
Ci sono tre limitazioni, all'uso di questo metodo. Il primo è relativo al [[refactoring]], gli altri due sono relativi all'estensione di classi.
* La prima limitazione consiste nel fatto che il refactoring di una classe esistente causa il malfunzionamento dei client esistenti.
* La seconda limitazione è dovuta al fatto che, poiché il pattern si basa sull'uso di costruttori privati, la classe non può essere estesa. Ogni sottoclasse dovrebbe invocare il costruttore ereditato, ma non può farlo nella misura in cui quest'ultimo è privato.
* La terza limitazione è dovuta al fatto che, se estendiamo una classe (ad esempio rendendo il costruttore 'protected'; rischioso ma possibile), le sottoclassi devono precedere la reimplementazione di tutti i metodi di factory con la stessa dichiarazione. La possibilità, fornita da alcuni linguaggi, di usare le classi reflection può, tuttavia, risolvere questo problema.
==Note==
{{Reflist}}
==Vedi anche==
* ''[[Design Patterns]]'', il libro della [[gang of four]] che ha introdotto il pattern
* [[Design pattern]], introduzione generale ai design pattern
== Altri progetti ==
| |||