设计模式-建造者模式（Builder）

建造者模式也叫生成器模式，是一种创建型模式，用来隐藏复合对象的创建过程，它把复合对象的创建过程加以抽象，通过子类继承和重载的方式，动态的创建具有复合属性的对象。

角色和职责：

1.抽象建造者（builder）-Builder:

   为创建一个产品对象的各个部件指定抽象接口

2.具体建造者（concrete builder）-ConcreteBuilder1、ConcreteBuilder2:

    现Builder的接口以构造和装配该产品的各个部件，定义并明确它所创建的表示，并提供一个检索产品的接口

3.设计者（Director）-Director:

    构造一个使用Builder接口的对象

4.产品（Product）-Product:

   表示被构造的复杂对象

 

UML图：

 

 

 

具体代码：

 

/**
 * 房子
 */
public class Product {
    private String basic;//地基
    private String wall;//墙
    private String roofed;//楼顶

    public String getWall() {
        return wall;
    }

    public void setWall(String wall) {
        this.wall = wall;
    }

    public String getRoofed() {
        return roofed;
    }

    public void setRoofed(String roofed) {
        this.roofed = roofed;
    }

    public String getBasic() {
        return basic;
    }

    public void setBasic(String basic) {
        this.basic = basic;
    }

    @Override
    public String toString() {
        return "Product{" +
                "basic='" + basic + '\'' +
                ", wall='" + wall + '\'' +
                ", roofed='" + roofed + '\'' +
                '}';
    }
}

/**
 * 建造者接口
 */
public interface Builder {
    void builderBasic();//建造地基
    void builderWall();//建造墙
    void builderRoofed();//建造楼顶
    Product getProduct();//生成房子
}

/**
 * 工程队1
 */
public class ConcreteBuilder1 implements Builder{
    private Product product = new Product();

    @Override
    public void builderBasic() {
        product.setBasic("建造房子1-地基");
    }

    @Override
    public void builderWall() {
        product.setWall("建造房子1-墙");
    }

    @Override
    public void builderRoofed() {
        product.setRoofed("建造房子1-楼顶");
    }

    @Override
    public Product getProduct() {
        return product;
    }
}

/**
 * 工程队2
 */
public class ConcreteBuilder2 implements Builder{
    private Product product = new Product();

    @Override
    public void builderBasic() {
        product.setBasic("建造房子2-地基");
    }

    @Override
    public void builderWall() {
        product.setWall("建造房子2-墙");
    }

    @Override
    public void builderRoofed() {
        product.setRoofed("建造房子2-楼顶");
    }

    @Override
    public Product getProduct() {
        return product;
    }
}

/**
 * 设计者
 */
public class Director {
    public Product constructProduct(Builder builder){
        builder.builderBasic();//先建造地基
        builder.builderWall();//再建造墙
        builder.builderRoofed();//最后建造楼顶
        return builder.getProduct();
    }
}

public class Main {
    public static void main(String[] args) {
        Director director = new Director();//设计师,设计房子

        Builder builder1 = new ConcreteBuilder1();//工程队1
        Product product1 = director.constructProduct(builder1);
        System.out.println(product1);

        Builder builder2 = new ConcreteBuilder2();//工程队2
        Product product2 = director.constructProduct(builder2);
        System.out.println(product2);
    }
}

结果：

Product{basic='建造房子1-地基', wall='建造房子1-墙', roofed='建造房子1-楼顶'}
Product{basic='建造房子2-地基', wall='建造房子2-墙', roofed='建造房子2-楼顶'}

 

应用场景：

建造者模式是在当创建复杂对象的复杂算法一个独立与该对象的组成部分以及它们的装配方式时适用的模式。

 

源码地址：https://github.com/qjm201000/design_pattern_builder.git