「这是我参与2022首次更文挑战的第32天，活动详情查看：2022首次更文挑战」

什么是建造者模式

建造者模式（Builder Pattern）使用多个简单的对象一步一步构建一个复杂的对象。
一个 Builder 类会一步一步构造最终的对象，该 Builder 类独立于其他对象。建造者模式主要解决在软件系统中，有时候面临着"一个复杂对象"的创建工作，其通常由各个部分的子对象用一定的算法构成；由于需求的变化，这个复杂对象的各个部分经常面临着剧烈的变化，但是将它们组合在一起的算法却相对稳定。

建造者模式的具体实现

结构图

建造者模式中的四个角色：

1、Builder：给出一个抽象接口，以规范产品对象的各个组成成分的建造。这个接口规定要实现复杂对象的哪些部分的创建，并不涉及具体的对象部件的创建。
2、ConcreteBuilder：实现Builder接口，针对不同的商业逻辑，具体化复杂对象的各部分的创建。在建造过程完成后，提供产品的实例。
3、Director：调用具体建造者来创建复杂对象的各个部分，在指导者中不涉及具体产品的信息，只负责保证对象各部分完整创建或按某种顺序创建。
4、Product：要创建的复杂对象

首先定义一个机器人的重要组成部分

这就是机器人模型，有头，有身体，有手，有脚。机器人都是由这个模型出来的。

package com.jony.designpattern.builder;

//机器人对象
public class Robot {
    private String head;
    private String body;
    private String hand;
    private String foot;

    public String getHead() {
        return head;
    }

    public void setHead(String head) {
        this.head = head;
    }

    public String getBody() {
        return body;
    }

    public void setBody(String body) {
        this.body = body;
    }

    public String getHand() {
        return hand;
    }

    public void setHand(String hand) {
        this.hand = hand;
    }

    public String getFoot() {
        return foot;
    }

    public void setFoot(String foot) {
        this.foot = foot;
    }
}

接下来定义一个造机器人的标准。一个把头、身体、手、脚造出来的标准

package com.jony.designpattern.builder;

//制造机器人接口，头 身体 手 脚
interface BuildRobot {
    public void buildHead();
    public void buildBody();
    public void buildHand();
    public void buildFoot();

    //最终返回整个机器人对象
    public Robot createRobot();
}

这样，一个建造机器人的标准就定义好了。依次创建各个部位，最后调用createRobot方法就可以返回一个我们想要的机器人。

现在机器人的模型和创建标准都有了，我们来创建一个医疗机器人

package com.jony.designpattern.builder;

//创建一个医疗机器人，
public class DoctorBuilder implements BuildRobot{
    Robot robot;

    public DoctorBuilder(){
        robot=new Robot();
    }

    @Override
    public void buildHead() {
        robot.setHead("拥有精湛的医疗技术");
    }

    @Override
    public void buildBody() {
        robot.setBody("坚强的身躯");
    }

    @Override
    public void buildHand() {
        robot.setHand("手拿手术刀");
    }

    @Override
    public void buildFoot() {
        robot.setFoot("脚穿运动鞋");
    }

    @Override
    public Robot createRobot() {
        return robot;
    }
}

这个医疗机器实现了BuildRobot造机器人标准的接口，最后提供了createRobot方法返回robot实体。

再来创建一个士兵机器人

package com.jony.designpattern.builder;

//创建一个士兵机器人，
public class SoldierBuilder implements BuildRobot{
    Robot robot;

    public SoldierBuilder(){
        robot=new Robot();
    }
    @Override
    public void buildHead() {
        robot.setHead("服从指令脑袋");
    }

    @Override
    public void buildBody() {
        robot.setBody("钢铁的身躯");
    }

    @Override
    public void buildHand() {
        robot.setHand("手拿冲锋枪");
    }

    @Override
    public void buildFoot() {
        robot.setFoot("脚穿大皮靴");
    }

    @Override
    public Robot createRobot() {
        return robot;
    }
}

创建建造者核心模块

好的，其实到这里呢，我们已经完成了建造的过程。那就这么简单的建造过程，还搞了一个建造模式吗？非也。接下来，就是介绍建造者模式的精髓，那就是director。这个director呢，就是来执行我们刚才的造人动作的。没错，精髓就是我们刚才的造人动作。我们先看代码：

package com.jony.designpattern.builder;

//建造者核心模块，调用具体建造者建造不同的机器人
public class RobotDirector {
    //管理造机器人的顺序，BuildRobot不同，建造的机器人就不同
    public Robot createRobotDirector(BuildRobot buildRobot){
        buildRobot.buildHead();
        buildRobot.buildBody();
        buildRobot.buildHand();
        buildRobot.buildFoot();
        return buildRobot.createRobot();
    }
}

建好了，这个Director类就跟个指挥官似，它有资源和工厂的。你跟它说要建造什么类型的机器人，只要传给它。它就给能你建造出来。

测试

package com.jony.designpattern.builder;

public class RobotBuildTest {
    public static void main(String[] args) {
        //生成建造者
        RobotDirector robotDirector=new RobotDirector();
        //建造士兵机器人
        Robot Soldier=robotDirector.createRobotDirector(new SoldierBuilder());
        System.out.println(Soldier.getHand());
        System.out.println(Soldier.getBody());
        System.out.println(Soldier.getHand());
        System.out.println(Soldier.getFoot());
        System.out.println("------------我是分割线------------");
        //建造医疗机器人
        Robot Doctor=robotDirector.createRobotDirector(new DoctorBuilder());
        System.out.println(Doctor.getHand());
        System.out.println(Doctor.getBody());
        System.out.println(Doctor.getHand());
        System.out.println(Doctor.getFoot());

    }
}

执行结果

现在如果我们想创建一个服务机器人，只需要创建一个娱乐机器人的Builder,然后交给Director,它就可以创建出来了。

总结：
1、通过以上代码我们可以发现，再创建其他类型机器人的时候，是很容易扩展的，没有修改之前的代码，符合开闭原则
2、代码解耦，模块化，方便维护，可以通过建造不同的Builder,就可以创建不同的产品。

缺点：
生成的产品组成部分基本相同，如我们生成机器人，都有头、身体、手、脚。如果产品之间差异太大，就不适合建造者模式了。

java设计模式-建造者模式(Builder Pattern)