Pattern Strategy

Fa parte della sezione Programmazione orientata agli oggetti del percorso Java di Coddy. Lezione 69 di 87.

Lo Strategy Pattern è un pattern comportamentale che ti permette di definire una famiglia di algoritmi, incapsulare ciascuno nella propria classe e renderli intercambiabili. Invece di codificare rigidamente un comportamento specifico, puoi sostituire gli algoritmi durante l'esecuzione senza modificare il codice che li utilizza.

Immagina un sistema di pagamento che supporta più metodi di pagamento. Senza lo Strategy Pattern, finiresti con una logica condizionale disordinata. Con esso, ogni metodo di pagamento diventa una propria strategia:

interface PaymentStrategy {
    void pay(int amount);
}

class CreditCardPayment implements PaymentStrategy {
    public void pay(int amount) {
        System.out.println("Paid " + amount + " via Credit Card");
    }
}

class PayPalPayment implements PaymentStrategy {
    public void pay(int amount) {
        System.out.println("Paid " + amount + " via PayPal");
    }
}

La classe contesto contiene un riferimento a una strategia e le delega il lavoro. Il punto fondamentale è che il contesto non sa quale strategia concreta sta usando. Conosce solo l'interfaccia:

class ShoppingCart {
    private PaymentStrategy paymentStrategy;
    
    public void setPaymentStrategy(PaymentStrategy strategy) {
        this.paymentStrategy = strategy;
    }
    
    public void checkout(int amount) {
        paymentStrategy.pay(amount);
    }
}

Ora puoi modificare dinamicamente il comportamento del pagamento:

ShoppingCart cart = new ShoppingCart();

cart.setPaymentStrategy(new CreditCardPayment());
cart.checkout(100);  // Pagati 100 con carta di credito

cart.setPaymentStrategy(new PayPalPayment());
cart.checkout(50);   // Pagati 50 con PayPal

Il Pattern Strategy dà il meglio quando hai più modi per eseguire un'azione e vuoi passare facilmente da uno all'altro. Aggiungere un nuovo metodo di pagamento significa semplicemente creare una nuova classe che implementa PaymentStrategy: non sono necessarie modifiche al codice esistente.

Sfida

Facile

Costruiamo un sistema di formattazione del testo usando lo Strategy Pattern! Creerai un sistema in cui diverse strategie di formattazione possono essere sostituite durante l'esecuzione per trasformare il testo in vari modi, perfetto per un'applicazione che deve supportare più formati di output.

Organizzerai il codice in quattro file:

TextFormatter.java: definisci l'interfaccia TextFormatter che tutte le strategie di formattazione implementeranno. Deve dichiarare un singolo metodo String format(String text) che prende una stringa e restituisce la versione formattata.
Formatters.java: crea tre strategie concrete che implementano la tua interfaccia TextFormatter:
UpperCaseFormatter - trasforma il testo convertendo tutte le lettere in maiuscolo.

LowerCaseFormatter - trasforma il testo convertendo tutte le lettere in minuscolo.

TitleCaseFormatter - mette in maiuscolo la prima lettera di ogni parola e converte il resto in minuscolo. Le parole sono separate da spazi.
TextEditor.java: crea la classe contesto che usa una strategia di formattazione. Il tuo TextEditor deve avere:
Un campo privato che contiene la strategia TextFormatter attualmente in uso.

Un metodo setFormatter(TextFormatter formatter) che cambia la strategia di formattazione attiva.

Un metodo publishText(String text) che applica al testo il formattatore attualmente in uso e stampa Published: [formatted text]. Se non è stato impostato alcun formattatore, deve stampare Published: [original text] senza modifiche.
Main.java: metti insieme il tuo sistema di strategie! Riceverai due input: il testo da formattare (String) e lo stile di formattazione (String: "upper", "lower" o "title").
Crea un TextEditor e chiama prima publishText con il testo ricevuto, prima di impostare un formattatore (per mostrare il comportamento predefinito).

Poi, in base allo stile ricevuto, imposta la strategia di formattazione appropriata e chiama di nuovo publishText con lo stesso testo per mostrare il risultato formattato.

Riceverai due input, nell'ordine indicato: il testo da formattare (String) e lo stile di formattazione (String).

Per esempio, con gli input hello world e title, l'output sarà:

Published: hello world
Published: Hello World

Nota come TextEditor non sappia nulla della logica di formattazione specifica. Si limita a delegare alla strategia attualmente impostata. Questo rende semplicissimo aggiungere nuovi stili di formattazione senza modificare il codice dell'editor!

Provalo tu

import java.util.Scanner;

class Main {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        String text = scanner.nextLine();
        String style = scanner.nextLine();
        
        // TODO: Crea un'istanza di TextEditor
        
        // TODO: Chiama publishText con il testo di input (prima di impostare un formatter)
        
        // TODO: In base allo stile inserito ("upper", "lower" o "title"),
        // imposta il formatter appropriato e chiama di nuovo publishText
        
    }
}