Le patron de méthode de fabrication fournit une interface pour la création d'objets, isolant le processus d'instanciation afin d'accroître la flexibilité.

Avantages :

• L'appelant peut créer un objet en connaissant uniquement son identifiant, ce qui réduit le couplage.
• Excellente extensibilité : l'ajout d'un produit nécessite seulement d'étendre une classe de farbique, clarifiant ainsi la structure du code.
• L'implémentation spécifique du produit est masquée, la'ppelant n'interagissant qu'avec l'interface.

Patron de Fabrique Simple

Ce patron implique une classe de fabrique qui détermine dynamiquement, à partir des paramètres fournis, la classe de produit à instancier. Ces classes de produit héritent d'une classe parent ou implémentent une interface. Toutefois, ce patron ne respecet pas le principe ouvert-fermé.

Patron de Méthode de Fabrication

Ce patron définit une interface pour la création d'objets, laissant les sous-classes décider de la classe concrète à instancier. Ainsi, une interface intermédiaire est introduite entre la fabrique et le produit, et la fabrique n'est plus responsable directe de la création. Les classes concrètes implémentent cette interface pour produire des instances spécifiques, favorisant l'extension sans modification du code existant. Cependant, cela peut engendrer un nombre accru de fichiers. En pratique, le choix entre ce patron et la fabrique simple dépend du contexte.

Exemple en Java :

Interface pour un produit générique :

// Interface définissant un produit
public interface Produit {
    void utiliser();
}

Implémentations concrètes :

// Implémentation d'un produit de type A
public class ProduitA implements Produit {
    @Override
    public void utiliser() {
        System.out.println("Utilisation du produit A");
    }
}

// Implémentation d'un produit de type B
public class ProduitB implements Produit {
    @Override
    public void utiliser() {
        System.out.println("Utilisation du produit B");
    }
}

Interface de fabrique :

// Interface pour la fabrique de produits
public interface FabriqueProduit {
    Produit creerProduit();
}

Implémentations de fabrique :

// Fabrique pour le produit A
public class FabriqueProduitA implements FabriqueProduit {
    @Override
    public Produit creerProduit() {
        return new ProduitA();
    }
}

// Fabrique pour le produit B
public class FabriqueProduitB implements FabriqueProduit {
    @Override
    public Produit creerProduit() {
        return new ProduitB();
    }
}

Exemple d'utilisation :

// Classe principale pour tester le patron
public class Application {
    public static void main(String[] args) {
        FabriqueProduit maFabrique = null;

        maFabrique = new FabriqueProduitA();
        Produit produitA = maFabrique.creerProduit();
        produitA.utiliser();

        maFabrique = new FabriqueProduitB();
        Produit produitB = maFabrique.creerProduit();
        produitB.utiliser();
    }
}

Ce patron garantit une bonne séparation des responsabilités et une modularité accrue, bien qu'il puisse entraîner une augmentation du nombre de classes.