Patron Stratégie

Fait partie de la section Programmation Orientée Objet du Journey Java de Coddy. Leçon 69 sur 87.

Le pattern Strategy est un patron de conception comportemental qui vous permet de définir une famille d’algorithmes, d’encapsuler chacun d’eux dans sa propre classe et de les rendre interchangeables. Au lieu de coder en dur un comportement spécifique, vous pouvez remplacer les algorithmes à l’exécution sans modifier le code qui les utilise.

Imaginez un système de paiement qui prend en charge plusieurs méthodes de paiement. Sans le modèle Strategy, vous vous retrouveriez avec une logique conditionnelle désordonnée. Avec ce modèle, chaque méthode de paiement devient sa propre stratégie :

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 context conserve une référence vers une stratégie et lui délègue le travail. L’essentiel est que le contexte ne sait pas quelle stratégie concrète il utilise. Il ne connaît que l’interface :

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

Vous pouvez maintenant modifier dynamiquement le comportement du paiement :

ShoppingCart cart = new ShoppingCart();

cart.setPaymentStrategy(new CreditCardPayment());
cart.checkout(100);  // Payé 100 via carte de crédit

cart.setPaymentStrategy(new PayPalPayment());
cart.checkout(50);   // Payé 50 via PayPal

Le modèle Strategy est particulièrement utile lorsque vous disposez de plusieurs façons d’effectuer une action et que vous souhaitez passer facilement de l’une à l’autre. Ajouter un nouveau mode de paiement signifie simplement créer une nouvelle classe qui implémente PaymentStrategy : aucune modification du code existant n’est nécessaire.

Défi

Facile

Construisons un système de formatage de texte utilisant le pattern Strategy ! Vous allez créer un système dans lequel différentes stratégies de formatage peuvent être remplacées à l’exécution afin de transformer le texte de diverses manières, ce qui est idéal pour une application devant prendre en charge plusieurs formats de sortie.

Vous allez organiser votre code sur quatre fichiers :

TextFormatter.java : définissez l’interface TextFormatter que toutes les stratégies de formatage implémenteront. Elle doit déclarer une seule méthode String format(String text) qui prend une chaîne et renvoie sa version formatée.
Formatters.java : créez trois stratégies concrètes qui implémentent votre interface TextFormatter :
UpperCaseFormatter - transforme le texte en lettres majuscules.

LowerCaseFormatter - transforme le texte en lettres minuscules.

TitleCaseFormatter - met en majuscule la première lettre de chaque mot tout en convertissant le reste en minuscules. Les mots sont séparés par des espaces.
TextEditor.java : créez la classe de contexte qui utilise une stratégie de formatage. Votre TextEditor doit comporter :
Un champ privé contenant la stratégie TextFormatter actuelle.

Une méthode setFormatter(TextFormatter formatter) qui modifie la stratégie de formatage active.

Une méthode publishText(String text) qui applique le formateur actuel au texte et affiche Published: [formatted text]. Si aucun formateur n’a été défini, elle doit afficher Published: [original text] sans modification.
Main.java : assemblez votre système de stratégies ! Vous recevrez deux entrées : le texte à formater (String) et le style de formatage (String : "upper", "lower" ou "title").
Créez un TextEditor et appelez d’abord publishText avec votre texte d’entrée avant de définir un formateur (pour illustrer le comportement par défaut).

Ensuite, en fonction du style fourni, définissez la stratégie de formatage appropriée et appelez à nouveau publishText avec le même texte afin d’afficher le résultat formaté.

Vous recevrez deux entrées dans l’ordre suivant : le texte à formater (String) et le style de formatage (String).

Par exemple, avec les entrées hello world et title, votre sortie serait :

Published: hello world
Published: Hello World

Remarquez que TextEditor ne connaît rien de la logique de formatage spécifique. Il délègue simplement le traitement à la stratégie actuellement définie. Il devient ainsi très facile d’ajouter de nouveaux styles de formatage sans modifier le code de l’éditeur !

Essayez vous-même

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: Créer une instance de TextEditor
        
        // TODO: Appeler publishText avec le texte d'entrée (avant de définir un formatter)
        
        // TODO: En fonction de l'entrée de style ("upper", "lower", ou "title"),
        // définir le formatter approprié et appeler publishText à nouveau
        
    }
}