Qu'est-ce que le modèle Builder dans les modèles de conception Java ?

1. Qu'est-ce que le mode constructeur ?

Nous savons que dans le processus de développement logiciel, nous devons parfois créer un objet très complexe, qui est généralement composé de plusieurs sous-composants dans certaines étapes.

Par exemple, lorsque nous assemblons nous-mêmes un ordinateur, nous devons l'assembler à partir du processeur, de la carte mère, de la mémoire, du disque dur, de la carte graphique, du châssis, du moniteur, du clavier, de la souris et d'autres composants. Par exemple, si une école a besoin d'acheter 100 ordinateurs, il lui est impossible d'acheter les pièces et de les assembler elle-même. Elle doit indiquer à l'acheteur la configuration dont elle a besoin, puis l'acheteur se rendra chez l'entreprise informatique pour l'acheter. L'entreprise les assemblera pour vous puis les remettra à l'acheteur et les remettra finalement à l'école.

L'exemple ci-dessus montre que chaque composant peut être sélectionné de manière flexible (y compris le niveau de différentes configurations informatiques), mais les étapes de création sont similaires. Cependant, la création de ce type de produit ne peut être décrite par le modèle d'usine introduit précédemment. Seul le modèle de constructeur peut bien décrire la création de ce type de produit.

2. Définition du modèle de constructeur

Définition du modèle de constructeur :

Séparez la construction d'un objet complexe de sa représentation afin que le même processus de construction puisse créer différentes représentations. Ce modèle de conception est appelé construction ou mode. Il décompose un objet complexe en plusieurs objets simples puis le construit étape par étape. Il sépare le changement de l'immuabilité, c'est-à-dire que les composants du produit restent inchangés, mais chaque partie peut être sélectionnée de manière flexible.

Résumé en une phrase : Séparez la construction d'un objet complexe de sa représentation, afin que le même processus de construction puisse créer différentes représentations

Type : Créer un modèle de classe

3. Avantages et inconvénients du modèle de constructeur

Avantages :

• Bonne encapsulation, séparation de la construction et de la présentation

• Bonne évolutivité, chaque constructeur spécifique est indépendant les uns des autres, ce qui favorise le découplage du système

• Le client n'a pas besoin de connaître les détails de l'interne composition du produit, les constructeurs peuvent affiner progressivement le processus de création sans aucun impact sur les autres modules, ce qui facilite le contrôle des risques de détail

Inconvénients :

• Les composants du produit doivent être les mêmes, ce qui limite sa portée d'utilisation

• Si les modifications internes du produit sont complexes. Si le produit change en interne, le constructeur devra également le modifier simultanément, et le coût de maintenance ultérieur sera plus élevé

Remarque :

Mode Constructeur et le mode usine ont des préoccupations différentes : le mode Constructeur se concentre sur le processus d'assemblage des composants, tandis que le modèle Factory Method se concentre davantage sur le processus de création de pièces, mais les deux peuvent être utilisés en combinaison.

4. Structure du mode Constructeur

Les principaux rôles du mode Constructeur sont les suivants :

• Rôle produit (Produit) : Il s'agit d'un objet complexe contenant plusieurs composants, et ses différents composants sont créés par des constructeurs spécifiques

• Abstract Builder (Builder) : Implémentez l'interface Builder pour construire et assembler les différentes parties du produit, définir et clarifier la représentation qu'il crée, et fournir une interface pour récupérer le produit

• Concrete Builder (Concrete Builder) : Construit un objet à l'aide de l'interface Builder pour guider le processus de construction

• Directeur : il appelle les méthodes de construction et d'assemblage des composants dans l'objet constructeur pour terminer la création d'objets complexes. Les produits spécifiques ne sont pas impliqués dans le réalisateur.

schéma structurel (référencé depuis Internet) :

5. Démonstration du code du mode constructeur

Par exemple, vous devez construire une voiture maintenant :

Catégorie de produit :

/**
 * 产品类
 */
public class Car {

    //车的建造过程

    private String wheel;  //车轮
    private String skeleton;  //车架
    private String engine;   //发动机


    public String getWheel() {
        return wheel;
    }

    public void setWheel(String wheel) {
        this.wheel = wheel;
    }

    public String getSkeleton() {
        return skeleton;
    }

    public void setSkeleton(String skeleton) {
        this.skeleton = skeleton;
    }

    public String getEngine() {
        return engine;
    }

    public void setEngine(String engine) {
        this.engine = engine;
    }
}

Catégorie instructeur :

/**
 * 指导者
 */

//汽车总监
public class CarDirector {

    public Car constructCar(ICarBuilder builder){
        builder.buildwheel();
        builder.buildSkeleton();
        builder.buildEngine();

        return builder.buildCar();
    }
}

Béton builder :

/**
 * 具体建造者：生产具体的东西
 */

public class ConcreteBuilder implements ICarBuilder{


    Car car;

    public ConcreteBuilder(){
        car = new Car();
    }

    @Override
    public void buildwheel() {
        car.setWheel("轮子");
    }

    @Override
    public void buildSkeleton() {
        car.setSkeleton("车身结构");
    }

    @Override
    public void buildEngine() {
        car.setEngine("发动机");
    }

    @Override
    public Car buildCar() {
        return this.car;
    }
}

Builder abstrait (interface) :

/**
 * 抽象建造者
 */
public interface ICarBuilder {

    public void buildwheel();   //构建车轮
    public void buildSkeleton();   //构建骨架
    public void buildEngine(); //构建发动机

    Car buildCar();

}

Classe de test :

public class Test {

    public static void main(String[] args){

        //新建一个总监（替你去买汽车）
        CarDirector director = new CarDirector();

        Car car = director.constructCar(new ConcreteBuilder());

        System.out.println(car.getWheel());
        System.out.println(car.getEngine());
        System.out.println(car.getSkeleton());
    }
}

Après avoir lu la démonstration de code et l'avoir combinée avec la première partie de l'article, vous pouvez la comprendre ! !

6. Scénarios d'application du modèle de constructeur

La seule différence entre le modèle de constructeur et le modèle d'usine est la création d'objets complexes. En d'autres termes, si vous créez des objets simples, vous utilisez généralement le modèle d'usine pour les créer, et si vous créez des objets complexes, vous pouvez envisager d'utiliser le modèle de constructeur

Principaux scénarios d'application :

La même méthode, une exécution différente ordre, Produisez des résultats différents
Plusieurs composants ou pièces peuvent être assemblés en un seul objet, mais les résultats sont différents
La classe de produits est très complexe, ou différentes séquences d'appel dans la classe de produits produisent des effets différents
L'initialisation d'un objet est particulièrement complexe, avec de nombreux paramètres, et de nombreux paramètres ont des valeurs par défaut
7. La différence entre le mode constructeur et le mode usine

Le mode constructeur accorde plus d'attention à l'ordre d'appel des méthodes, tandis que l'usine est en mode usine. mode Concentrez-vous sur la création d'objets
L'intensité de la création d'objets est différente. Le modèle de constructeur crée des objets complexes, composés de divers composants complexes. Les objets créés par le modèle d'usine sont tous les mêmes
L'accent est mis sur la création d'objets. différent. Le modèle d'usine nécessite simplement de créer l'objet, et le modèle de constructeur doit non seulement créer l'objet, mais sait également de quelles parties l'objet est composé

• Le mode constructeur est différent selon l'ordre dans le processus de construction, et la composition finale des composants de l'objet est également différente

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!