[JAVA] Einführung in Entwurfsmuster (Builder)

Dieser Artikel fasst Builder zusammen. Laut Wikipedia "ist es möglich, dynamische Objekte zu erstellen, indem der Prozess der Objekterstellung abstrahiert wird." Referenz: Builder-Muster

Dieses Muster besteht darin, dass in einer Klasse mehrere Konstruktoren zusammen gruppiert werden können. Es kann nur ein Konstruktor mit demselben Namen und Argument definiert werden. Wenn Sie mehrere Konstruktoren erstellen, ändern sich die Anzahl der Argumente und der Datentyp. Wenn die Anzahl zunimmt, wird es schwierig, dies zu tun, und die Lesbarkeit des Quellcodes nimmt ab. Also gehen wir die Argumente aus, die der Konstruktor erhält.

Implementierungsbeispiel

Erstellen Sie eine Klasse von Personen, die Namen, Alter, Größe und Gewicht als Parameter beibehalten

** Vor dem Anwenden des Musters **

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

** Nach dem Anwenden des Musters **

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

Ergebnis

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

Wie oben erwähnt, ist die Sichtbarkeit des Quellcodes schlecht, wenn eine Klasse mehrere Konstruktoren enthält, und die Codemenge nimmt zu. Setzen Sie daher den Konstruktor in die Director-Klasse, erstellen Sie eine Instanz mit der HumanBuilder-Klasse, die die Builder-Schnittstelle implementiert, und Main.java greift über Getter auf die Instanz zu.