Qu'est-ce que le modèle Java Builder ? Comment y parvenir ? (avec code)

Le contenu de cet article porte sur ce qu'est le modèle de générateur Java ? Comment y parvenir ? (Le code est ci-joint), qui a une certaine valeur de référence. Les amis dans le besoin peuvent s'y référer. J'espère qu'il vous sera utile.

Mode Constructeur

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

  Builder Pattern utilise plusieurs objets simples pour construire un objet complexe étape par étape.
Une classe Builder construira l'objet final étape par étape. Cette classe Builder est indépendante des autres objets.
Le modèle de construction résout principalement le problème de la création d'un « objet complexe » dans les systèmes logiciels, qui est généralement composé de sous-objets de différentes parties en utilisant un certain algorithme En raison de changements dans les exigences, cet objet complexe Le les parties individuelles d'un objet sont souvent confrontées à des changements drastiques, mais les algorithmes qui les assemblent sont relativement stables .

2. Implémentation spécifique du mode constructeur

Schéma de structure

Quatre rôles en mode constructeur :

1. 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.

2. ConcreteBuilder : implémente l'interface Builder pour créer 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.

3. Directeur : Appelez des constructeurs spécifiques pour créer diverses parties d'objets complexes. Le directeur n'implique pas d'informations sur des produits spécifiques. Il est uniquement responsable de s'assurer que toutes les parties de l'objet sont complètement créées. ou dans un certain ordre.

4. Produit : L'objet complexe à créer.

Implémentation du code Java

1. Créer une classe d'entité humaine

package com.designpattern.builderPattern;

/**
 * 对象 人
 *
 * @author zhongtao on 2018/9/17
 */
public class Human {

    private String head;
    private String body;
    private String hand;
    private String foot;

    public String getHead() {
        return head;
    }

    public void setHead(String head) {
        this.head = head;
    }

    public String getBody() {
        return body;
    }

    public void setBody(String body) {
        this.body = body;
    }

    public String getHand() {
        return hand;
    }

    public void setHand(String hand) {
        this.hand = hand;
    }

    public String getFoot() {
        return foot;
    }

    public void setFoot(String foot) {
        this.foot = foot;
    }
}

2. Créer une interface de constructeur humain

package com.designpattern.builderPattern;

/**
 * 造人接口 规定造人的规范 需要头、身体、手、脚
 *
 * @author zhongtao on 2018/9/17
 */
public interface BuilderHuman {

    void buildHead();

    void buildBody();

    void buildHand();

    void buildFoot();

    /**
     * 返回创建的对象
     */
    Human createHuman();

}

3. ConcreteBuilder crée différents types de personnes

tallPerson

package com.designpattern.builderPattern;

/**
 * 高个子的人
 *
 * @author zhongtao on 2018/9/17
 */
public class TallPersonBuilder implements BuilderHuman {

    Human human;

    public TallPersonBuilder() {
        human = new Human();
    }

    @Override
    public void buildHead() {
        human.setHead("普通的头脑");
    }

    @Override
    public void buildBody() {
        human.setBody("壮实，高大的身体");
    }

    @Override
    public void buildHand() {
        human.setHand("长手");
    }

    @Override
    public void buildFoot() {
        human.setFoot("长脚");
    }

    @Override
    public Human createHuman() {
        return human;
    }
}

smartHuman

package com.designpattern.builderPattern;

/**
 * 聪明的人
 *
 * @author zhongtao on 2018/9/17
 */
public class SmartHumanBuilder implements BuilderHuman {

    Human human;

    public SmartHumanBuilder() {
        human = new Human();
    }

    @Override
    public void buildHead() {
        human.setHead("高智商的头脑");
    }

    @Override
    public void buildBody() {
        human.setBody("健康的身体");
    }

    @Override
    public void buildHand() {
        human.setHand("普通的手");
    }

    @Override
    public void buildFoot() {
        human.setFoot("普通的脚");
    }

    @Override
    public Human createHuman() {
        return human;
    }
}

4. Le cœur du modèle de constructeur Director appelle des constructeurs spécifiques Créer différentes personnes.

package com.designpattern.builderPattern;

/**
 * 管理造人的顺序 BuilderHuman不同，则创建的人不同
 * @author zhongtao on 2018/9/17
 */
public class HumanDirector {

    public Human createHumanByDirector(BuilderHuman builderHuman){
        builderHuman.buildHead();
        builderHuman.buildBody();
        builderHuman.buildHand();
        builderHuman.buildFoot();

        return builderHuman.createHuman();
    }
}

5. Test du mode constructeur

package com.designpattern.builderPattern;

import org.junit.Test;

/**
 * 测试
 *
 * @author zhongtao on 2018/9/17
 */
public class BuilderPatternTest {

    /**
     * 测试建造者模式
     */
    @Test
    public void test() {
        HumanDirector humanDirector = new HumanDirector();
        //创建高个子的人
        Human humanByDirector = humanDirector.createHumanByDirector(new TallPersonBuilder());
        System.out.println(humanByDirector.getHead());
        System.out.println(humanByDirector.getBody());
        System.out.println(humanByDirector.getHand());
        System.out.println(humanByDirector.getFoot());

        System.out.println("------简单的分割线------");
        //创建聪明的人
        Human smartHuman = humanDirector.createHumanByDirector(new SmartHumanBuilder());
        System.out.println(smartHuman.getHead());
        System.out.println(smartHuman.getBody());
        System.out.println(smartHuman.getHand());
        System.out.println(smartHuman.getFoot());
    }
}

3. Avantages et inconvénients du mode constructeur

Avantages :

1. Builder est indépendant et facile à développer.

2. Rises détaillés faciles à contrôler.

Inconvénients :

1. Les produits doivent avoir quelque chose en commun et la portée est limitée.

2. Si les changements internes sont complexes, il y aura de nombreux cours de construction.

Remarque :

Différence par rapport au mode usine, le mode constructeur accorde plus d'attention à l'ordre d'assemblage des pièces.

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!