Caractéristiques et scénarios d'application du modèle de constructeur Java

Mode Constructeur

Définition et caractéristiques du mode

Définition du modèle Builder : fait référence à la séparation de 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é modèle Builder. 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.

Les principaux avantages de ce modèle sont les suivants :

Chaque constructeur spécifique est indépendant les uns des autres, ce qui est propice à l'expansion du système. Le client n'a pas besoin de connaître les détails de la composition interne du produit, ce qui facilite le contrôle détaillé des risques.

Les inconvénients sont les suivants :

Les composants du produit doivent être les mêmes, ce qui limite son champ d'utilisation. Si les modifications internes du produit sont complexes, ce modèle ajoutera de nombreuses classes de constructeur.

Le mode constructeur et le mode usine ont des objectifs différents : le mode constructeur se concentre sur le processus d'assemblage des composants, tandis que le mode méthode usine se concentre davantage sur le processus de création de composants, mais les deux peuvent être utilisés en combinaison. .

(Vidéo recommandée : vidéo Java tutoriel)

Structure et implémentation du modèle

Le modèle Builder est composé de celui-ci se compose de quatre éléments : le produit, le constructeur abstrait, le constructeur concret et le commandant. Analysons maintenant sa structure de base et sa méthode de mise en œuvre.

1. Structure du pattern

Les principaux rôles du pattern Builder sont les suivants.

Rôle du produit (Product) : Il s'agit d'un objet complexe contenant plusieurs composants, et ses composants individuels sont créés par des constructeurs spécifiques. Constructeur abstrait (Builder) : il s'agit d'une interface qui contient des méthodes abstraites pour créer divers sous-composants d'un produit, et contient généralement également une méthode getResult() qui renvoie des produits complexes. Concrete Builder : Implémente l'interface Builder pour compléter les méthodes de création spécifiques de chaque composant d'un produit complexe. 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. Le directeur n'implique pas d'informations spécifiques sur le produit.

Le schéma de structure est le suivant :

2) Mise en œuvre du patron

(1) Produit. rôle : Un objet complexe contenant plusieurs composants.

public class Product {
    private String partA;
    private String partB;
    private String partC;
    public void setPartA(String partA) {
        this.partA = partA;
    }
    public void setPartB(String partB) {
        this.partB = partB;
    }
    public void setPartC(String partC) {
        this.partC = partC;
    }
    public void show() {
        //显示产品的特性
    }
}

(2) Générateur abstrait : contient des méthodes abstraites pour créer divers sous-composants du produit.

public abstract class Builder {
    //创建产品对象
    protected Product product = new Product();
    public abstract void buildPartA();
    public abstract void buildPartB();
    public abstract void buildPartC();
    //返回产品对象
    public Product getResult() {
        return product;
    }
}

(3) Constructeur concret : implémente l'interface du constructeur abstrait.

public class ConcreteBuilder extends Builder {
    public void buildPartA() {
        product.setPartA("建造 PartA");
    }
    public void buildPartB() {
        product.setPartA("建造 PartB");
    }
    public void buildPartC() {
        product.setPartA("建造 PartC");
    }
}

(4) Commander : Appelez des méthodes dans le constructeur pour terminer la création d'objets complexes.

public class Director {
    private Builder builder;
    public Director(Builder builder) {
        this.builder = builder;
    }
    //产品构建与组装方法
    public Product construct() {
        builder.buildPartA();
        builder.buildPartB();
        builder.buildPartC();
        return builder.getResult();
    }
}

(5) Scénarios d'application du client

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

modèle

Le modèle de constructeur crée des objets complexes et ses produits Les pièces individuelles sont souvent confrontées à des changements drastiques , mais l'algorithme qui les combine est relativement stable, il est donc généralement utilisé dans les situations suivantes.

L'objet créé est plus complexe et se compose de plusieurs composants. Chaque composant est confronté à des changements complexes, mais la séquence de construction entre les composants est stable. Les algorithmes utilisés pour créer des objets complexes sont indépendants des composants de l'objet et de la manière dont ils sont assemblés, c'est-à-dire que le processus de construction et la représentation finale du produit sont indépendants.

Cet article provient du site Web php chinois, colonne tutoriel Java, bienvenue pour apprendre !

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!