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

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.

Quest-ce que le modèle Builder dans les modèles de conception Java ? 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;
    }
}

Copier après la connexion

Catégorie instructeur :

/**
 * 指导者
 */

//汽车总监
public class CarDirector {

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

        return builder.buildCar();
    }
}

Copier après la connexion

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;
    }
}

Copier après la connexion

Builder abstrait (interface) :

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

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

    Car buildCar();

}

Copier après la connexion

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());
    }
}

Copier après la connexion

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 :

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!