Patron Fabrique

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

Le Factory Pattern est un patron de conception de création qui délègue la création d’objets à une méthode ou une classe distincte. Au lieu d’utiliser directement new dans votre code, vous demandez à une fabrique de créer les objets pour vous. Cela est particulièrement utile lorsque vous avez plusieurs classes liées qui partagent une interface ou une classe parente commune.

Considérons un système de notifications capable d’envoyer des e-mails, des SMS ou des notifications push. Sans fabrique, votre code devrait connaître chaque classe concrète :

// Sans Factory - le client doit connaître toutes les classes concrètes
Notification notification;
if (type.equals("email")) {
    notification = new EmailNotification();
} else if (type.equals("sms")) {
    notification = new SMSNotification();
}

Avec le pattern Factory, vous centralisez cette logique de création :

public interface Notification {
    void send(String message);
}

public class EmailNotification implements Notification {
    public void send(String message) {
        System.out.println("Email: " + message);
    }
}

public class SMSNotification implements Notification {
    public void send(String message) {
        System.out.println("SMS: " + message);
    }
}

public class NotificationFactory {
    public static Notification create(String type) {
        if (type.equals("email")) {
            return new EmailNotification();
        } else if (type.equals("sms")) {
            return new SMSNotification();
        }
        return null;
    }
}

Maintenant, le code du client est plus propre et ne dépend pas de classes concrètes :

Notification notification = NotificationFactory.create("email");
notification.send("Hello!");  // Sortie : Email: Hello!

Le principal avantage est que l’ajout de nouveaux types de notifications nécessite uniquement la mise à jour de la fabrique : le code client reste inchangé. Cela suit le principe de programmer par rapport à une interface, ce qui rend votre système plus flexible et plus facile à étendre.

Défi

Facile

Construisons un système de dessin de formes à l'aide du patron Factory ! Au lieu de créer directement des objets de forme partout dans votre code, vous centraliserez la logique de création dans une fabrique qui produit différents types de formes à partir d'un simple identifiant de chaîne.

Vous organiserez votre code sur quatre fichiers :

Shape.java : Définissez une interface appelée Shape qui sert de contrat commun pour toutes les formes. Votre interface doit déclarer une seule méthode draw() qui ne renvoie rien, mais affiche des informations sur la forme dessinée.
Shapes.java : Créez trois classes qui implémentent votre interface Shape :
Circle - sa méthode draw() doit afficher Drawing a Circle

Rectangle - sa méthode draw() doit afficher Drawing a Rectangle

Triangle - sa méthode draw() doit afficher Drawing a Triangle
ShapeFactory.java : Créez la classe fabrique qui gère la création des formes. Votre ShapeFactory doit posséder une méthode statique createShape(String type) qui renvoie un Shape. Selon le paramètre type :
- Si type est égal à "circle", renvoyez un nouveau Circle
- Si type est égal à "rectangle", renvoyez un nouveau Rectangle
- Si type est égal à "triangle", renvoyez un nouveau Triangle
- Pour toute autre valeur, renvoyez null
Main.java : Assemblez votre système de fabrique ! Vous recevrez deux entrées : deux types de formes (tous deux des chaînes).
Pour chaque entrée, utilisez votre ShapeFactory pour créer la forme et stockez-la dans une variable Shape. Si la fabrique renvoie une forme valide (pas null), appelez sa méthode draw(). Si elle renvoie null, affichez Unknown shape: [type], où [type] est l'entrée fournie.

Traitez les deux entrées dans l'ordre, chacune sur sa propre ligne de sortie.

Vous recevrez deux entrées dans l'ordre : le premier type de forme (String), puis le second type de forme (String).

Remarquez que votre classe Main n'utilise jamais new Circle() ou new Rectangle() directement. Elle ne connaît que l'interface Shape et demande à la fabrique de créer les objets. C'est là toute la puissance du patron Factory : le code client est découplé des classes concrètes !

Essayez vous-même

import java.util.Scanner;

class Main {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        
        // Lire deux types de formes
        String type1 = scanner.nextLine();
        String type2 = scanner.nextLine();
        
        // TODO: Utiliser ShapeFactory pour créer la première forme
        // Si la forme n'est pas null, appeler draw()
        // If the shape is null, print "Unknown shape: [type]"
        
        // TODO: Faire de même pour la deuxième forme
        
    }
}