[JAVA] Introduction aux modèles de conception (Builder)

Cet article résume Builder. Selon wikipedia, "En faisant abstraction du processus de création d'objets, il est possible de créer des objets dynamiques." Référence: Modèle de générateur

Ce modèle est que dans une classe, s'il y a plusieurs constructeurs, ils peuvent être regroupés. Un seul constructeur avec le même nom et argument peut être défini, et lors de la création de plusieurs constructeurs, le nombre d'arguments et le type de données changeront. Au fur et à mesure que le nombre augmente, cela devient difficile à faire et la lisibilité du code source diminue. Nous sortons donc les arguments que le constructeur reçoit.

Exemple d'implémentation

Créez une classe de personnes qui gardent les noms, l'âge, la taille et le poids comme paramètres

** Avant d'appliquer le motif **

public class Human {
    private String name;
    private Integer age;
    private Integer height;
    private Integer weight
    public Human(String name, Integer age, Integer height, Integer weight) {
        this.name = name;
        this.age = age;
        this.height = height;
        this.weight = weight;
    }
    public Human(String name) {
        this.name = name;
    }
    public Human(Integer age) {
        this.age = age;
    }
    public Human(Integer height, Integer weight) {
        this.height = height;
        this.weight = weight;
    }

}
public class Main {
    public static void main(String[] args) {
        Human ha = new Human("kusa");
        Human hb = new Human(1);
        Human hc = new Human(170, 70);
    }
}

** Après avoir appliqué le motif **

Builder.java

public interface Builder {
    public void name(String name);
    public void age(Integer age);
    public void height(Integer height);
    public void weight(Integer weight);
    public Human getResult();
}

HumanBuilder.java

class HumanBuilder implements Builder {
    private Human human;

    public HumanBuilder() { this.human = new Human(); }

    @Override
    public void name(String name) { human.setName(name); }
    @Override
    public void age(Integer age) { human.setAge(age); }
    @Override
    public void height(Integer height) { human.setHeight(height); }
    @Override
    public void weight(Integer weight) { human.setWeight(weight); }
    @Override
    public Human getResult() { return this.human; }
}

Human.java

public class Human {
    private String name;
    private Integer age;
    private Integer height;
    private Integer weight;

    public void setName(String name) { this.name = name;}
    public void setAge(Integer age) { this.age = age;}
    public void setHeight(Integer height) { this.height = height; }
    public void setWeight(Integer weight) { this.weight = weight; }

    public String getName() { return this.name; }
    public Integer getAge() { return this.age; }
    public Integer getHeight() { return this.height; }
    public Integer getWeight() { return this.weight; }

    public void hello() {
        System.out.printf("name is %s %n",name);
        System.out.printf("age is %d %n", age);
        System.out.printf("height is %d %n", height);
        System.out.printf("weight is %d %n", weight);
    }
}

Director.java

class Director {
    private Builder builder;

    public Director(Builder builder) { this.builder = builder; }

    public void construct() {
        builder.name("kusakari");
        builder.age(30);
        builder.height(175);
        builder.weight(70);
    }
}

Main.java

public class Main {
    public static void main(String[] args) {
        Builder builder = new HumanBuilder();
        Director director = new Director(builder);
        director.construct();
        builder.getResult().hello();
    }
}

résultat

$ java Main
name is kusakari 
age is 30 
height is 175 
weight is 70

Comme mentionné ci-dessus, s'il y a plusieurs constructeurs dans la classe, la visibilité du code source sera médiocre et la quantité de code augmentera. Par conséquent, placez le constructeur sur la classe Director, créez une instance avec la classe HumanBuilder qui implémente l'interface Builder et Main.java accède à l'instance via getter.