什么是建造者模式

1. 建造者模式又叫生成器模式, 是一种对象构建模式
2. 可以将复杂对象的构建过程抽象出来, 使这个抽象过程的不同实现方法可以构造出不同表现的对象

• 建造者模式有4个角色
  Product(产品): 具体的产品对象
  Builder(抽象建造者): 创建一个Product对象的各个部件指定的接口或抽象类
  ConcreteBuilder(具体建造者): 实现接口, 构建和装配各个部件
  Director(指挥者): 构建一个使用Builder接口的对象。隔离了客户与对象的生产过程，同时负责控制产品对象的生产过程

案例需求

1. 建房子, 打地基、切墙、封顶等流程
2. 房子分普通房子、高楼等

• 传统方式实现

/**
 * 抽象的建造者
 */
public abstract class HouseBuilder {

    //打地基
    public abstract void buildBase();
    //砌墙
    public abstract void buildWall();
    //封顶
    public abstract void buildRoofed();

    //建房
    public void buildHouse(){
        buildBase();
        buildWall();
        buildRoofed();
    }
}

/**
 * 普通房子
 */
public class CommonHouse extends HouseBuilder {
    @Override
    public void buildBase() {
        System.out.println("普通房子打地基");
    }

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

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

# 测试
public static void main(String[] args) {
    CommonHouse commonHouse = new CommonHouse();
    commonHouse.buildHouse();
}

# 输出
普通房子打地基
普通房子砌墙
普通房子封顶

分析: 这种方式比较好理解，但是扩展和维护性不好，把房子和创建房子的过程封装在一起，耦合性太高。

• 建造者模式实现

# 产品
public class House {
    private String base;
    private String wall;
    private String roofed;
    // getter、setter和toString方法省略
}

/**
 * 抽象的构建者
 */
public abstract class HouseBuilder {
    protected House house = new House();
    //抽象方法
    public abstract void buildBase();
    public abstract void buildWall();
    public abstract void buildRoofed();
    //构建房子
    public House buildHouse(){
        return house;
    }
}

/**
 * 具体构建者
 * 修建普通房子
 */
public class CommonHouse extends HouseBuilder {
    @Override
    public void buildBase() {
        house.setBase("普通房子打地基");
    }

    @Override
    public void buildWall() {
        house.setWall("普通房子砌墙");
    }

    @Override
    public void buildRoofed() {
        house.setRoofed("普通房子封顶");
    }
}

/**
 * 指挥者
 */
public class HouseDirector {

    HouseBuilder houseBuilder = null;

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

    public House createHouse(){
        houseBuilder.buildBase();
        houseBuilder.buildWall();
        houseBuilder.buildRoofed();
        return houseBuilder.buildHouse();
    }
}

# 测试
public static void main(String[] args) {
    HouseDirector houseDirector = new HouseDirector(new CommonHouse());
    House house = houseDirector.createHouse();
    System.out.println(house);
}
输出:
House{base='打地基', wall='砌墙', roofed='封顶'}

如果我们要新增别墅类型的房子，怎么增加？
只需要增加具体构建者VillaHouse类

/**
 * 具体构建者
 * 修建别墅
 */
public class VillaHouse extends HouseBuilder{
    @Override
    public void buildBase() {
        house.setBase("别墅打地基");
    }

    @Override
    public void buildWall() {
        house.setWall("别墅砌墙");
    }

    @Override
    public void buildRoofed() {
        house.setRoofed("别墅封顶");
    }
}

public static void main(String[] args) {

    HouseDirector houseDirector = new HouseDirector(new VillaHouse());
    House house = houseDirector.createHouse();
    System.out.println(house);
}
输出:
House{base='别墅打地基', wall='别墅砌墙', roofed='别墅封顶'}

• 建造者模式注意事项和细节
  1.客户端不必知道产品内部组成的细节，将产品本身和产品的创建过程解耦，使用相同的创建过程即可创建不同的产品对象
  2.每一个创建者都是独立，与其他创建者无关，因此可以很方便的替换具体的创建者或新增创建者，用户可以使用不同的创建者创建不同的对象

抽象工厂模式 VS 创造者模式

1.抽象工厂模式实现对同一类产品的创建，不用关心构建过程，只关心什么产品用什么工厂即可
2.建造者模式则是要求按照指定的蓝图建造产品，它的主要目的是通过组装配件而产生一个新产品