Qu'est-ce que le patron de conception Factory…

Le motif Factory Builder, ou plutôt Factory Method en combinaison avec Builder, est une combinaison de deux motifs qui améliore la création d'objets complexes.

Factory Method définit une interface pour créer un objet, mais permet aux sous-classes de décider quelle classe instancier. Il délègue la responsabilité de la création de l'objet aux classes filles.

Builder sépare la construction d'un objet complexe de sa représentation, de sorte que le même processus de construction peut créer différentes représentations. Il permet de construire un objet étape par étape, en utilisant une chaîne d'appels de méthodes.

La combinaison de ces motifs est souvent rencontrée dans des scénarios où il est nécessaire de créer plusieurs variantes d'un objet complexe. Factory Method détermine quel type de Builder doit être utilisé, puis le Builder s'occupe de comment créer cet objet avec différentes configurations.

Exemple d'utilisation : Lorsque vous avez une hiérarchie de classes d'objets nécessitant une initialisation complexe, et que vous souhaitez créer ces objets avec différentes configurations.

Structure d'interaction typique :

Fournisseur: Possède une méthode qui retourne une instance d'un Builder spécifique en fonction des paramètres d'entrée ou de son type.
Builder: Possède des méthodes pour configurer étape par étape les paramètres de l'objet complexe et une méthode finale build(), qui retourne l'objet prêt.
Produit: L'objet complexe créé par le Builder.

Avantages :

Amélioration de la lisibilité et de la gestion du code lors de la création d'objets complexes.
Flexibilité dans la création de différentes configurations du même type d'objet.
Séparation de la logique de création de l'objet de sa représentation.
Facilite l'ajout de nouveaux types de produits (en utilisant Factory Method) ou de nouvelles méthodes de construction (en utilisant Builder).

Inconvénients :

Augmentation du nombre de classes dans le projet.
Peut être excessif pour des objets simples.

Exemple (pseudocode) :

// Produit
class ComplexObject {
    private String partA;
    private int partB;

    // constructeur privé
    private ComplexObject(String partA, int partB) {
        this.partA = partA;
        this.partB = partB;
    }

    // Classe interne Builder
    public static class Builder {
        private String partA;
        private int partB;

        public Builder setPartA(String partA) {
            this.partA = partA;
            return this;
        }

        public Builder setPartB(int partB) {
            this.partB = partB;
            return this;
        }

        public ComplexObject build() {
            return new ComplexObject(partA, partB);
        }
    }
}

// Fábrica que retourne un Builder
class ComplexObjectFactory {
    public static ComplexObject.Builder createDefaultBuilder() {
        return new ComplexObject.Builder()
                .setPartA("defaultA")
                .setPartB(10);
    }

    public static ComplexObject.Builder createSpecialBuilder() {
        return new ComplexObject.Builder()
                .setPartA("specialA")
                .setPartB(50);
    }
}

// Utilisation :
// ComplexObject obj1 = ComplexObjectFactory.createDefaultBuilder().build();
// ComplexObject obj2 = ComplexObjectFactory.createSpecialBuilder().setPartA("customA").build();

Qu'est-ce que le patron de conception Factory Builder?