Statement: For reprint, please attach the link to the original text

Tip: The title sequence starts with 4, which corresponds to the order in which the various design pattern notes are published. For example, in the first article, the prototype pattern, a common Java design pattern for beginners, starts with 3.

4. Builder Mode (common)

4.1 Introduction to the Builder model

4.2 Builder model case

Create product class Computer first:

/ * * *@Auther: csp1999
 * @Date: 2020/11/08 / would *@Description: Computer */
public class Computer {
    private String cpu;
    private String memory;
    private String mainboard;
    private String disk;
    private String power;

    public String getCpu(a) {
        return cpu;
    }

    public void setCpu(String cpu) {
        this.cpu = cpu;
    }

    public String getMemory(a) {
        return memory;
    }

    public void setMemory(String memory) {
        this.memory = memory;
    }

    public String getMainboard(a) {
        return mainboard;
    }

    public void setMainboard(String mainboard) {
        this.mainboard = mainboard;
    }

    public String getDisk(a) {
        return disk;
    }

    public void setDisk(String disk) {
        this.disk = disk;
    }

    public String getPower(a) {
        return power;
    }

    public void setPower(String power) {
        this.power = power;
    }

    @Override
    public String toString(a) {
        return "Computer{" +
                "cpu='" + cpu + '\' ' +
                ", memory='" + memory + '\' ' +
                ", mainboard='" + mainboard + '\' ' +
                ", disk='" + disk + '\' ' +
                ", power='" + power + '\' ' +
                '} '; }}Copy the code

Next create the Abstract Builder interface Builder:

/ * * *@Auther: csp1999
 * @Date: 2020/11/08/10:38
 * @DescriptionThe abstract builder interface * * declares the builder's public method */
public interface Builder {

    /** * interface method */
    void buildCpu(a);

    void buildMainBoard(a);

    void buildDisk(a);

    void buildPower(a);

    void buildMemory(a);

    Computer createComputer(a);
}
Copy the code

Then create the concrete builder class A (high powered computer builder)HighComputerBuilder and the concrete builder class B(low powered computer builder) LowComputerBuilder:

/ * * *@Auther: csp1999
 * @Date: 2020/11/08 / they *@Description: Specific builder A: High spec PC builder */
public class HighComputerBuilder implements Builder {

    private Computer computer = new Computer();

    @Override
    public void buildCpu(a) {
        computer.setCpu("The high-end CPU");
    }

    @Override
    public void buildMainBoard(a) {
        computer.setMainboard("High quality motherboard");
    }

    @Override
    public void buildDisk(a) {
        computer.setDisk("High spec disk");
    }

    @Override
    public void buildPower(a) {
        computer.setPower("High power supply");
    }

    @Override
    public void buildMemory(a) {
        computer.setMemory("High memory");
    }

    @Override
    public Computer createComputer(a) {
        return computer;// Returns the computer object}}Copy the code

/ * * *@Auther: csp1999
 * @Date: 2020/11/08 / they *@Description: Concrete builder class B: low power PC builder */
public class LowComputerBuilder implements Builder {

    private Computer computer = new Computer();

    @Override
    public void buildCpu(a) {
        computer.setCpu("With low CPU");
    }

    @Override
    public void buildMainBoard(a) {
        computer.setMainboard("Low motherboard");
    }

    @Override
    public void buildDisk(a) {
        computer.setDisk("Low disk");
    }

    @Override
    public void buildPower(a) {
        computer.setPower("Low power supply");
    }

    @Override
    public void buildMemory(a) {
        computer.setMemory("Low memory");
    }

    @Override
    public Computer createComputer(a) {
        return computer;// Returns the computer object}}Copy the code

Finally, the commander **Director ** controls the production process:

/ * * *@Auther: csp1999
 * @Date: 2020/11/08 / he *@Description: The Director class: controls the assembly process, hands the requirements to the builder, who creates the objects * * Decouples the product from the creation process, creates different products using the same creation process, and controls the production process * * The Director directs the assembly process, and the Builder handles the details */
public class Director {

    public Computer create(Builder builder){
        builder.buildCpu();
        builder.buildDisk();
        builder.buildMainBoard();
        builder.buildMemory();
        builder.buildPower();

        returnbuilder.createComputer(); }}Copy the code

When we’re done, let’s test:

@Test
public void testBuilder(a){
    Director director = new Director();// Declare the commander
    // The conductor constructs the low configuration computer
    Computer low_computer = director.create(new LowComputerBuilder());
    // The conductor directs the construction of the high configuration computer
    Computer high_computer = director.create(new HighComputerBuilder());
    System.out.println(low_computer);
    System.out.println(high_computer);
}
Copy the code

Output result:

Computer{cpu='with low CPU', memory='Low memory', mainboard='Low profile motherboard', disk='Low disk', power='Low power supply'}
Computer{cpu='the high-end CPU', memory='High memory', mainboard='High quality motherboard', disk='High spec disk', power='High power supply'}
Copy the code

Builder mode case completed!

4.3 summary