Strategy pattern

Da Wikipedia, l'enciclopedia libera.


Nella programmazione ad oggetti, lo strategy pattern è uno dei pattern fondamentali, definiti originariamente dalla gang of four.

Lo strategy pattern è uno dei pattern comportamentali. L'obiettivo di questa architettura è isolare un algoritmo all'interno di un oggetto. Il pattern strategy è utile in quelle situazioni dove sia necessario modificare dinamicamente gli algoritmi utilizzati da un'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 una tra le visite ed eseguirla sull'albero per ottenere il risultato voluto. Il design pattern Iterator si basa proprio su questo.

Questo pattern prevede che gli algoritmi siano intercambiabili tra loro (in base ad una qualche condizione) in modo trasparente al client che ne fa uso. In altre parole: la famiglia di algoritmi che implementa una funzionalità (ad esempio di visita o di ordinamento) esporta sempre la medesima interfaccia, in questo modo il client dell'algoritmo non deve fare nessuna assunzione su quale sia la strategia istanziata in un particolare istante.

Struttura[modifica | modifica sorgente]

Struttura del Design Pattern Strategy

Esempio[modifica | modifica sorgente]

L'esempio seguente è in 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'algoritimo 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'algoritimo 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>();
        //Algortimo 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 algortimo 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 codice;
 
        public Document(string title, string codice)
        {
            this.title = title;
            this.codice = codice;
        }
        public String getTitle()
        {
            return title;
        }
        public void setCodice(String codice)
        {
            this.codice = codice;
        }
    }

Utilizzo dello Strategy: nel seguente esempio vediamo come ordinare una lista di documenti con due diversi algortimi di ordinamento senza che la classe che si occupa di ordinare i documenti conosca l'implemetazione dell'algortimo di ordinamento.

public class SortDocument {
 
    public void sort(List<Document> documents){
 
    QuickDocumentSort quickDocumentSort = new QuickdocumentSort();
 
    SortedDocumentList sortedDocumentList = new SortedDocumentList( documents );
 
    //Aggiungi l'algoritimo per effettuare l'ordinamento
    sortedDocumentList.setSortStrategy(quickDocumentSort);
 
    //Ordina i documenti usando l'algortimo quickDocumentSort
    sortedDocumentList.sort();
 
    MergeDocumentSort mergeDocumentSort = new MergeDocumentSort ();
 
    sortedDocumentList.setSortStrategy(mergeDocumentSort);
 
    //Ordina di nuovo la lista usando un altro algortimo di ordinamento
     sortedDocumentList.sort();
    }
}

Considerazioni[modifica | modifica sorgente]

Bibliografia[modifica | modifica sorgente]

Voci correlate[modifica | modifica sorgente]

Altri progetti[modifica | modifica sorgente]