设计模式（创建型）----------建造者模式------------保姆级教学

定义

将一个复杂对象的构建和定义分离，使得同样的构建过程通过传入参数不同可以创建不同的复杂对象。

这个构建过程中是用户不知道的，用户只管获取到目标复杂对象。

具体实现（样例）

1.我们需要创建一个复杂类（即目标复杂类），这里我的复杂类为主机。

package design_pattern.builder;

public class Computer {
    public String CPU;
    public String mainBoard;
    public String hardDisk;

    @Override
    public String toString() {
        return "Computer{" +
                "CPU='" + CPU + '\'' +
                ", mainBoard='" + mainBoard + '\'' +
                ", hardDisk='" + hardDisk + '\'' +
                '}';
    }
}

2.我们需要抽象出一个Builder类，该抽象类用于定义构建的过程

//下面需求是组装一个主机，主机需要很多的零部件（这里主机就是复杂对象，由很多零件对象组成）
public abstract class Builder {
    public abstract void buildCPU();

    public abstract void buildMainBoard();

    public abstract void buildHardDisk();

    public abstract Computer getComputer();
}

3.我们针对一种类型的主机进行创建，即创建一个主机类继承抽象类Builder

package design_pattern.builder;

/**
 * 作为电脑的真正构建者，即装机员
 */
public class ComputerBuilder extends Builder{
    private Computer computer = new Computer();

    @Override
    public void buildCPU() {
        computer.CPU = "i9";
    }

    @Override
    public void buildMainBoard() {
        computer.mainBoard = "Intel";
    }

    @Override
    public void buildHardDisk() {
        computer.hardDisk = "512G";
    }

    @Override
    public Computer getComputer() {
        return this.computer;
    }
}

4.这样我们的主机构建类就创建完毕，此时我们需要一个调度类或监督类（Director），即调用复杂对象Builder的角色。

package design_pattern.builder;

/**
 * 作为电脑的指挥者，在这里就是电脑的消费者或购买者
 */
public class Director {
    public void buyComputer(Builder builder) {
        builder.buildCPU();
        builder.buildMainBoard();
        builder.buildHardDisk();
    }
}

样例测试

package design_pattern.builder;

/**
 * 这是一个建造者模式使用的一个实际场景
 */
public class Buy {
    public static void main(String[] args) {
        //首先是一个消费者（Director）在电脑城闲逛
        Director director = new Director();
        //消费者发现一家店还不错（下面抽象类代表电脑城拥有很多电脑店铺，后面创建的对象代表选中了哪一家店铺）
        Builder builder = new ComputerBuilder();
        //消费者看好了以后就决定在这家店里购买主机并让店员进行安装
        director.buyComputer(builder);
        //店员安装完毕，交给消费者
        Computer computer = builder.getComputer();
        System.out.println(computer.toString());
    }
}

优缺点

优点

1.解耦
将复杂对象的定义和构建部分分开，解耦便于维护和拓展
2.易于控制复杂对象的创建
因为我们是在抽象类builder中对复杂对象创建进行了定义，所以查看构建过程十分清晰。
3.易于拓展
如果我们想要增加一种主机的创建，则直接继承builder抽象类，实现对应的抽象方法即可。

缺点

1.扩展时必须构建方法类似
如果是两个完全不同的产品，则在产品生产过程中因为构建流程差异过大导致建造者模式无法成功创建出对应的复杂对象。