Patron Template Method

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

Le pattern Template Method est un patron de conception comportemental qui définit la structure générale d’un algorithme dans une classe de base, permettant aux sous-classes de remplacer certaines étapes sans modifier la structure globale. Considérez-le comme une recette : le processus général de préparation reste le même, mais les ingrédients ou les techniques individuelles peuvent varier.

Le modèle utilise une classe abstraite avec une méthode modèle qui appelle une séquence d’étapes. Certaines étapes disposent d’implémentations par défaut, tandis que d’autres sont abstraites et doivent être implémentées par les sous-classes :

abstract class DataProcessor {
    // Méthode template - définit la structure de l'algorithme
    public final void process() {
        readData();
        processData();
        saveData();
    }
    
    abstract void readData();
    abstract void processData();
    
    // Implémentation par défaut (méthode hook)
    void saveData() {
        System.out.println("Saving to default location");
    }
}

class CSVProcessor extends DataProcessor {
    void readData() {
        System.out.println("Reading CSV file");
    }
    
    void processData() {
        System.out.println("Parsing CSV data");
    }
}

class XMLProcessor extends DataProcessor {
    void readData() {
        System.out.println("Reading XML file");
    }
    
    void processData() {
        System.out.println("Parsing XML data");
    }
}

La méthode modèle est généralement marquée final afin d’empêcher les sous-classes de modifier la structure de l’algorithme. Lorsqu’elle est appelée, elle exécute la même séquence pour toutes les sous-classes :

DataProcessor csv = new CSVProcessor();
csv.process();
// Sortie :
// Lecture du fichier CSV
// Analyse des données CSV
// Enregistrement à l'emplacement par défaut

Le patron de conception Template Method est idéal lorsque vous avez des algorithmes qui partagent la même structure, mais qui diffèrent par certaines étapes spécifiques. Il favorise la réutilisation du code en plaçant la logique commune dans la classe de base, tout en permettant la personnalisation grâce à l’héritage.

Défi

Facile

Construisons un système de génération de documents utilisant le patron Template Method ! Vous allez créer un framework dans lequel différents types de documents (rapports et factures) suivent le même processus de génération, tout en personnalisant certaines étapes. C’est idéal lorsque le flux de travail global est fixe, mais que les détails varient selon le type de document.

Vous allez organiser votre code dans quatre fichiers :

DocumentGenerator.java : créez la classe de base abstraite qui définit la méthode modèle. Votre DocumentGenerator doit comporter :
Une méthode final appelée generateDocument() qui définit la structure de l’algorithme en appelant trois étapes dans l’ordre : createHeader(), createBody() et createFooter().

Deux méthodes abstraites : createHeader() et createBody(), que les sous-classes doivent implémenter.

Une méthode crochet createFooter() avec une implémentation par défaut qui affiche --- End of Document ---.
ReportGenerator.java : créez une sous-classe concrète pour générer des rapports. Elle doit recevoir un titre de rapport (String) via son constructeur.
La méthode createHeader() affiche === REPORT: [title] ===

La méthode createBody() affiche Report content goes here...

Utilisez le pied de page par défaut hérité.
InvoiceGenerator.java : créez une autre sous-classe concrète pour générer des factures. Elle doit recevoir un nom de client (String) et un montant (double) via son constructeur.
La méthode createHeader() affiche *** INVOICE ***

La méthode createBody() affiche Customer: [name] sur une ligne, puis Amount Due: $[amount] sur la ligne suivante (formatez le montant avec deux décimales).

Redéfinissez createFooter() pour afficher Thank you for your business!
Main.java : rassemblez votre système utilisant la méthode modèle ! Vous recevrez trois entrées : un titre de rapport (String), un nom de client (String) et un montant de facture (double).
Créez un ReportGenerator avec le titre et appelez generateDocument(). Affichez une ligne vide pour séparer les éléments. Créez ensuite un InvoiceGenerator avec le nom du client et le montant, puis appelez generateDocument().

Vous recevrez trois entrées dans l’ordre suivant : le titre du rapport (String), le nom du client (String) et le montant de la facture (double).

Par exemple, avec les entrées Q4 Sales, Acme Corp et 1500.00, votre sortie sera :

=== REPORT: Q4 Sales ===
Report content goes here...
--- End of Document ---

*** INVOICE ***
Customer: Acme Corp
Amount Due: $1500.00
Thank you for your business!

Remarquez que les deux types de documents suivent le même processus en trois étapes défini dans la méthode modèle, mais que chacun personnalise les étapes différemment. Le ReportGenerator utilise le pied de page par défaut, tandis que InvoiceGenerator fournit le sien. C’est toute la puissance des méthodes crochets dans le patron Template Method !

Essayez vous-même

import java.util.Scanner;

class Main {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        
        // Lire les entrées
        String reportTitle = scanner.nextLine();
        String customerName = scanner.nextLine();
        double invoiceAmount = scanner.nextDouble();
        
        // TODO: Créer un ReportGenerator avec le titre et appeler generateDocument()
        
        // TODO: Afficher une ligne vide pour la séparation
        
        // TODO: Créer un InvoiceGenerator avec le nom du client et le montant, et appeler generateDocument()
        
    }
}