Strategy pattern: differenze tra le versioni
Contenuto cancellato Contenuto aggiunto
m robot Modifico: fr:Stratégie (patron de conception) |
m →Altri progetti: Aggiunto il parametro "Preposizione" nel template "Interprogetto" |
||
| (65 versioni intermedie di 50 utenti non mostrate) | |||
Riga 1:
{{S|
Nella [[Programmazione orientata agli oggetti|programmazione ad oggetti]], lo '''strategy pattern''' è uno dei [[design pattern|pattern]] fondamentali, definiti originariamente dalla [[Gang of Four (scrittori)|Gang of Four]].
L'obiettivo di questa architettura è isolare un [[algoritmo]] all'interno di un oggetto, in maniera tale da risultare utile in quelle situazioni dove sia necessario modificare dinamicamente gli algoritmi utilizzati da un'[[applicazione (informatica)|applicazione]]. Si pensi ad esempio alle possibili visite in una struttura ad albero (visita anticipata, simmetrica, posticipata); mediante il pattern strategy è possibile selezionare a tempo di [[esecuzione (informatica)|esecuzione]] una tra le visite ed eseguirla sull'albero per ottenere il risultato voluto. Anche il design pattern [[Iterator pattern|Iterator]] si basa su questo concetto di isolamento.
Questo pattern prevede che gli algoritmi siano intercambiabili tra loro, in base ad una specificata condizione, in modalità trasparente al client che ne fa uso. In altre parole, data una famiglia di algoritmi che implementa una certa funzionalità, come può essere ad esempio un algoritmo di visita oppure di ordinamento, essa dovrà esportare sempre la medesima interfaccia, così il [[client]] dell'algoritmo non dovrà fare nessuna assunzione su quale sia la strategia istanziata in un particolare istante.
== Struttura ==
[[ == Esempio ==
L'esempio seguente è stato codificato con il linguaggio di programmazione [[Java (linguaggio di programmazione)|Java]].
<syntaxhighlight lang="java">
// "Strategy"
public interface ISortStrategy
{
public void sort(List<Document> documentList);
}
// "classe concreta Strategy"
public class QuickDocumentSort implements ISortStrategy
{
public void sort(List<Document> documentList)
{
// Call overloaded Sort
sortQuickSort(documentList);
}
// Ordina usando l'algoritmo del quickSort
private void sortQuickSort(List<Document> list)
{
//Ordina i documenti usando l'algoritmo del quicksort
Collection.quickSort(list,left,right);
}
}
// "classe concreta Strategy"
public class MergeDocumentSort implements ISortStrategy
{
public void sort(List<Document> documentList)
{
// Call overloaded Sort
sortMergeSort(documentList);
}
// Ordina usando l'algoritmo del mergeSort
private void sortMergeSort(List<Document> list)
{
//Ordina i documenti usando l'algoritmo del mergeSort
Collection.mergeSort(list,left,right);
}
}
//Contesto in cui viene usato il pattern strategy. Abbiamo una lista di documenti che deve essere ordinata.
public class SortedDocumentList
{
//Lista di documenti
private List<Document> documentList = new List<Document>();
//Algoritmo per l'ordinamento dei documenti
private ISortStrategy sortStrategy;
public SortedDocumentList( List<Document> documents ){
this.documentList = documents;
}
public void setSortStrategy(ISortStrategy sortStrategy)
{
this.sortStrategy = sortStrategy;
}
public void add(Document document)
{
documentList.add(document);
}
//Ordina la lista di documenti usando un algoritmo di ordinamento
public void sort()
{
//Ordina i documenti
sortStrategy.sort(documentList);
// Display results
for (Document document: documentList )
{
System.out.println(document.getTitle());
}
}
}
class Document
{
private String title;
private String code;
public Document(String title, String code)
{
this.title = title;
this.code = code;
}
public String getTitle()
{
return title;
}
public void setCode(String code)
{
this.code = code;
}
}
</syntaxhighlight>
Utilizzo dello Strategy: nel seguente esempio vediamo come ordinare una lista di documenti con due diversi algoritmi di ordinamento senza che la classe che si occupa di ordinare i documenti conosca l'implementazione dell'algoritmo di ordinamento.
<syntaxhighlight lang="java">
public class SortDocument {
public void sort(List<Document> documents) {
QuickDocumentSort quickDocumentSort = new QuickdocumentSort();
SortedDocumentList sortedDocumentList = new SortedDocumentList(documents);
//Aggiungi l'algoritmo per effettuare l'ordinamento
sortedDocumentList.setSortStrategy(quickDocumentSort);
//Ordina i documenti usando l'algoritmo quickDocumentSort
sortedDocumentList.sort();
MergeDocumentSort mergeDocumentSort = new MergeDocumentSort();
sortedDocumentList.setSortStrategy(mergeDocumentSort);
//Ordina di nuovo la lista usando un altro algoritmo di ordinamento
sortedDocumentList.sort();
}
}
</syntaxhighlight>
== Considerazioni ==
{{...|informatica}}
== Bibliografia ==
* [[Erich Gamma|Gamma, E.]], [[Richard Helm|Helm, R.]], [[Ralph Johnson (informatico)|Johnson, R.]] e [[John Vlissides|Vlissides, J.]], '' [[Design Patterns]]: elementi per il riuso di software a oggetti'', Addison Wesley, 1995, ISBN 88-7192-150-X
** Originale: ''Design Patterns: Elements of Reusable Object-Oriented Software'', Addison Wesley, 1995, ISBN 0-201-63361-2
== Voci correlate ==
* [[Decorator]]
* [[Command pattern]]
* [[Factory method]]
== Altri progetti ==
{{interprogetto|preposizione=sullo}}
{{Design pattern}}
{{portale|informatica}}
[[Categoria:Design pattern]]
| |||