小白必备之建造者模式详解，你值得拥有！

定义

建造者模式又叫生成器模式，是一种对象构建模式。它可以将复杂对象的建造过程抽象出来（抽象类别），使这个抽象过程的不同实现方法可以构造出不同表现（属性）的对象。

建造者模式是一步一步创建一个复杂的对象，它允许用户只通过指定复杂对象的类型和内容就可以构建它们，用户不需要指定内部的具体构建细节。

角色
builder（抽象建造者）： 创建一个Product对象的各个部件指定的 接口/抽象类。
ConcreteBuilder（具体建造者）： 实现Builder接口，针对不同的商业逻辑，具体化复杂对象的各部分的创建。在构造过程完成后，提供产品的实例。
Director（指导者）： 调用具体建造者来创建复杂对象的各个部分，在指导者中不涉及具体产品的信息，只负责保证对象各部分完整创建或按某种顺序创建。
Product（产品类）： 一个具体的产品对象。

实例讲解

本次实例讲解以建造房屋为例子。

产品类

//产品 -> Product
public class House {
    private String baise;
    private String wall;
    private String roofed;

    public String getBaise() {
        return baise;
    }

    public void setBaise(String baise) {
        this.baise = baise;
    }

    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 abstract class HouseBuilder {

    protected House house = new House();

    //建造流程，抽象的方法
    public abstract void buildBasic();
    public abstract void buildWalls();
    public abstract void roofed();

    //将产品返回
    public House buildHouse() {
        return house;
    }
}

具体建造者

public class CommonHouse extends HouseBuilder {

    @Override
    public void buildBasic() {
        System.out.println("普通房子打地基");
    }

    @Override
    public void buildWalls() {
        System.out.println("普通房子砌墙");
    }

    @Override
    public void roofed() {
        System.out.println("普通房子屋顶");
    }
}


public class VillaHouse extends HouseBuilder {
    @Override
    public void buildBasic() {
        System.out.println("别墅地基");
    }

    @Override
    public void buildWalls() {
        System.out.println("别墅砌墙");
    }

    @Override
    public void roofed() {
        System.out.println("别墅屋顶");
    }
}

指导者

//指挥者,动态指定，返回产品
public class HouseDirector {

    HouseBuilder houseBuilder = null;

    //set方法传入
    public void setHouseBuilder(HouseBuilder houseBuilder) {
        this.houseBuilder = houseBuilder;
    }

    //构造器传入
    public HouseDirector(HouseBuilder houseBuilder) {
        this.houseBuilder = houseBuilder;
    }

    //如何处理交给指挥者（Director）
    public House createHouse() {
        //建造
        houseBuilder.buildBasic();
        houseBuilder.buildWalls();
        houseBuilder.roofed();

        //返回
        return houseBuilder.buildHouse();
    }

}

客户

public class client {

    public static void main(String[] args) {

        CommonHouse commonHouse = new CommonHouse();
        VillaHouse villaHouse = new VillaHouse();

        //构造器方式
        HouseDirector houseDirector = new HouseDirector(commonHouse);

        //普通盖房子，返回
        House house = houseDirector.createHouse();
        //set方式
        houseDirector.setHouseBuilder(villaHouse);

        System.out.println("-----------------------");
        //别墅盖房子，返回
        House house1 = houseDirector.createHouse();
    }
}

运行结果

总结

优点：

1. 使用建造者模式可以使客户端不必知道产品内部的组成细节。
2. 便于控制细节风险。

缺点：

1. 产品必须有共同点，范围有限制。
2. 如内部变化复杂，会有很多的建造类。

使用场景

1. 需要生成的产品对象有复杂的内部结构，这些产品对象具备共性.
2. 需要生产的产品对象的属性相互依赖.

觉得博主写的不错的读者大大们，可以点赞关注和收藏哦，谢谢各位！