建造者模式

基本介绍

建造者模式就是将产品和产品建造过程解耦(分离)，比如工地上建房子，对于我们用户来说，不需要知道房子的建造过程，只要到时候直接去开发商购买房子就行了。对与开发商来说，只用去指挥手下的包工头让他们去建造。其实这就是建造者模式，把创建对象的一些复杂过程封装起来，我们需要的时候，直接调用就行了。

建造模式四个角色
1）Product(产品角色):一个具体的产品对象，比如我上面说的,房子
2）Builder(抽象建造者):给出一个抽象类/接口，规定如何去建造房子。给下面的包工头一个建房子的规范。
3) ConcerteBuilder(具体建造者):实现接口，构建和装配各个组件，就像上面的包工头。
4）Director(指挥者)：构建一个使用Builder接口的对象。它主要是创建一个复杂的对象。有两个作用,一是:隔离客户与对象的创建过程，二是:复杂控制产品对象的生产过程，指挥者也就是上面的开发商。

代码实现

第一步：定义House (房子)

/**
 * 房子
 */
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;
    }
}

第三步：具体建造者（具体的A，B包工头两个，一个是普通楼房的包工头，一个是高楼的包工头）

//普通楼房的包工头
public class CommonHouse extends HouseBuilder {
    @Override
    public void buildBasic() {
        System.out.println("包工头A给普通房子打地基5m");
    }

    @Override
    public void buildWalls() {
        System.out.println("包工头A给普通房子砌墙10cm");
    }

    @Override
    public void roofed() {
        System.out.println("包工头A给普通房子封顶");
    }
}

//高楼的包工头
public class HightBuilding extends HouseBuilder{
    @Override
    public void buildBasic() {
        System.out.println("包工头B给高楼打地基100m");
    }

    @Override
    public void buildWalls() {
        System.out.println("包工头B给高楼砌墙20cm");
    }

    @Override
    public void roofed() {
        System.out.println("包工头B给高楼的透明屋顶");
    }
}

第四步：Director（开发商指挥者）

//指挥者，这里去指定制作流程
public class HouseDirector {

    HouseBuilder houseBuilder = null;

    HouseDirector(HouseBuilder houseBuilder){
        this.houseBuilder = houseBuilder;
    }


    public HouseBuilder getHouseBuilder() {
        return houseBuilder;
    }

    public void setHouseBuilder(HouseBuilder houseBuilder) {
        this.houseBuilder = houseBuilder;
    }

    public House constractHouse(){
        houseBuilder.buildBasic();
        houseBuilder.buildWalls();
        houseBuilder.roofed();
        return houseBuilder.buildHouse();
    }
}

第五步：测试（也就是用户）

public class Client {

    public static void main(String[] args) {
        //盖普通房子
        HouseBuilder abstractHouse = new CommonHouse();
        //准备创建房子的指挥者
        HouseDirector houseDirector = new HouseDirector(abstractHouse);
        //完成盖房
        House house = houseDirector.constractHouse();

        //盖高楼
        HouseBuilder hightHouse = new HightBuilding();
 		//准备创建高楼的指挥者
        houseDirector.setHouseBuilder(hightHouse);
  	 	//完成盖房
        houseDirector.constractHouse();

    }
}

运行结果：

总结

优点：

1. 将产品本身与产品创建过程进行解耦。
2. 将复杂产品的创建步骤分解在不同的方法中，使得创建过程更加清晰。
3. 增加新的具体建造者无需修改原有类库的代码，指挥者类针对抽象建造者类编程，易于拓展，符合“开闭原则“。

缺点：

1. 如果产品之间的差异性很大，则不适合使用建造者模式，因此其使用范围受到一定的限制。
2. 如果产品的内部变化复杂，可能会导致需要定义很多具体建造者类来实现这种变化，导致系统变得很庞大。