Explication détaillée du modèle de créateur des modèles de conception

Définition (De l'Encyclopédie Baidu) :
L'idée principale est de séparer un « algorithme de construction d'objet complexe » de ses « composants et méthodes d'assemblage », afin que l'algorithme de composant et la méthode d'assemblage puissent Répondre aux changements de manière indépendante ;
La réutilisation du même algorithme de construction peut créer différentes représentations, et différents processus de construction peuvent réutiliser la même méthode d'assemblage de composants

Diagramme de classes UML  :

 

Code spécifique :

public class Client {public static void main(String[] args) {
        Director d = new Director(new ConcreteBuilder());
        d.construct();
    }
}public class Director {
    Builder builder;

    Director(Builder builder){this.builder = builder;
    }void construct(){
        builder.buildPart();
    }
}public class ConcreteBuilder implements Builder {private Product product;public Product getResult() {return product;
    }

    @Overridepublic void buildPart() {

    }
}public class Product {

}

Par exemple :

Un La voiture est composée de nombreuses pièces, allant du moteur au rétroviseur. Il est évidemment irréaliste d'assembler une voiture et de la donner à l'utilisateur
Après tout, ce que l'utilisateur veut, c'est juste une voiture, il ne le fait pas. Je ne me soucie pas de la façon dont vous le construisez.
Par exemple, si je veux une Audi, en parlant de l'exemple ci-dessus, je dirai au directeur que je veux construire une Audi.
Ensuite, Director trouve l'interface Builder (instance ConcreteBuilder) correspondant à Audi. ConcreteBuilder connaît les différentes parties et étapes de construction d'Audi
Par exemple, construisez d'abord un grand cadre, puis sélectionnez un moteur, puis sélectionnez les pneus appropriés, et enfin appuyez sur Un rétroviseur, ces étapes sont le processus de buildPart. Bref, c'est un processus compliqué,
mais pour les utilisateurs, c'est Audi et ne se soucie pas de ces processus compliqués.
De plus, cet exemple semble être très similaire à l'usine abstraite, mais il y a une différence importante. L'usine est uniquement responsable de la production des différentes pièces de la voiture et n'est pas responsable de son assemblage.
C'est une partie importante pour distinguer les deux modes.

Composants :

Builder : Fournit une interface abstraite pour standardiser la construction de chaque composant de l'objet produit. Cette interface spécifie quelles parties de l'objet complexe doivent être créées et n'implique pas la création de composants d'objet spécifiques.
L'exemple ci-dessus correspond à l'assemblage de diverses pièces de la voiture, y compris le moteur, etc.
ConcreteBuilder : implémente l'interface Builder et crée concrètement chaque partie d'un objet complexe pour différentes logiques métier. Une fois le processus de construction terminé, fournissez des exemples du produit.
Correspond à ce qui précède est le constructeur qui assemble Audi, et ajoute les roues des machines agricoles étape par étape...
Réalisateur : appelle des constructeurs spécifiques pour créer diverses parties d'objets complexes. Le réalisateur n'implique pas de produit spécifique. informations. Il est uniquement responsable de s’assurer que toutes les parties de l’objet sont créées complètement ou dans un certain ordre.
Le mot « Directeur » signifie directeur, et la responsabilité est très claire : la planification. Dans l'exemple ci-dessus, si mon idée en tant que producteur est d'utiliser Audi, le réalisateur demandera à ConcreteBuilder de le faire.
Produit : L'objet complexe à créer.
Celui ci-dessus est Audi.

Avantages et inconvénients :
Avantages :
Couplage lâche : Décomposer les étapes de création de produits complexes en différentes méthodes rend le processus de création plus clair et nous permet d'être plus précis pour contrôler le processus de génération d’objets complexes.
Meilleure réutilisation : les produits de construction, ainsi que l'assemblage et le fractionnement rendent les produits de construction réutilisables.

Inconvénients :
Les produits créés par le mode constructeur ont généralement plus en commun et leurs composants sont similaires. Si les différences entre les produits sont grandes, le mode constructeur n'est pas adapté, donc son champ d'utilisation. est soumis à certaines restrictions.
Si les modifications internes du produit sont complexes, cela peut entraîner la nécessité de définir de nombreuses classes de constructeur spécifiques pour implémenter de telles modifications, ce qui rend le système très volumineux.

Référence :

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!