23种设计模式——建造者模式（创建型模式）

定义

建造者模式（Builder Pattern）是一种创建型设计模式，它允许通过一步步构建复杂对象，同时使构建过程的各个部分可以独立变化。该模式常用于当需要构造的对象比较复杂，并且涉及多个步骤时，提供一种灵活的对象创建方式。

结构

抽象建造者类

该接口规定要实现复杂对象的那部分的创建，并不涉及具体的部件的创建

具体建造者类

实现抽象建造者接口，完成复杂产品的各个部件的具体创建方法，在构建完成后，提供产品实例

产品类

要创建的复杂对象

指挥者类

调用具体建造者来创建复杂对象的各个部分，在指导者中不涉及具体的产品信息，只负责保证对象各部分完整创建或按照某种顺序创建。

代码实现

public interface Builder {

    Bike BIKE = new Bike();

    void buildFrame();

    void buildSeat();

    Bike createBike();

}

public class jatBuilder implements Builder{
    @Override
    public void buildFrame() {
        BIKE.setFrame("捷安特碳纤维车架");
    }

    @Override
    public void buildSeat() {
        BIKE.setSeat("捷安特真皮坐垫");
    }

    @Override
    public Bike createBike() {
        return BIKE;
    }
}

public class xdsBuilder implements Builder{
    @Override
    public void buildFrame() {
        BIKE.setFrame("喜德盛碳纤维车架");
    }

    @Override
    public void buildSeat() {
        BIKE.setSeat("喜德盛真皮坐垫");
    }

    @Override
    public Bike createBike() {
        return BIKE;
    }
}

public class Director {

    private Builder builder;

    public Director(Builder builder) {
        this.builder = builder;
    }

    public Bike construct() {
        builder.buildFrame();
        builder.buildSeat();
        return builder.createBike();
    }
}

public class Client {

    public static void main(String[] args) {
        // 构建xds单车
        Builder xdsBuilder = new xdsBuilder();
        Director director1 = new Director(xdsBuilder);
        Bike xdsBike = director1.construct();
        System.out.println("xds单车的frame是：" + xdsBike.getFrame());
        System.out.println("xds单车的seat是：" + xdsBike.getSeat());

        // 构建jat单车
        Builder jatBuilder = new jatBuilder();
        Director director2 = new Director(jatBuilder);
        Bike jatBike = director2.construct();
        System.out.println("jat单车的frame是：" + jatBike.getFrame());
        System.out.println("jat单车的seat是：" + jatBike.getSeat());
    }
}

使用场景

1、需要通过多个步骤创建复杂对象时。

2、希望创建的对象能够通过不同的顺序和组合来创建时。

3、需要在不修改代码的情况下，构造不同的对象变体时。

优点

1、建造者模式的封装性好，使用建造者模式可以有效的封装变化。在使用建造者模式的场景中，一般产品类和建造者类是比较稳定的，因此将主要的业务逻辑封装在指挥者类中对整体而言可以取得较好的稳定性。

2、产品本身和产品创建过程解耦

3、容易拓展

缺点

建造者模式适用于所创建的产品具有较多的共同点，其组成部分相似，若产品之间的差异性很大，则不适合使用建造者模式，因此使用范围受到一定的限制。

拓展--构造器创建对象

public class Computer {
    private String cpu;
    private String memory;
    private String hardDisk;
    private String videoCard;
    private String mainBoard;
    private String power;
    private String keyboard;
    private String mouse;

    public String getVideoCard() {
        return videoCard;
    }

    public void setVideoCard(String videoCard) {
        this.videoCard = videoCard;
    }

    public String getMainBoard() {
        return mainBoard;
    }

    public void setMainBoard(String mainBoard) {
        this.mainBoard = mainBoard;
    }

    public String getCpu() {
        return cpu;
    }

    public void setCpu(String cpu) {
        this.cpu = cpu;
    }

    public String getMemory() {
        return memory;
    }

    public void setMemory(String memory) {
        this.memory = memory;
    }

    public String getHardDisk() {
        return hardDisk;
    }

    public void setHardDisk(String hardDisk) {
        this.hardDisk = hardDisk;
    }

    public String getPower() {
        return power;
    }

    public void setPower(String power) {
        this.power = power;
    }

    public String getKeyboard() {
        return keyboard;
    }

    public void setKeyboard(String keyboard) {
        this.keyboard = keyboard;
    }

    public String getMouse() {
        return mouse;
    }

    public void setMouse(String mouse) {
        this.mouse = mouse;
    }

    @Override
    public String toString() {
        return "Computer{" +
        "cpu='" + cpu + '\'' +
        ", memory='" + memory + '\'' +
        ", hardDisk='" + hardDisk + '\'' +
        ", videoCard='" + videoCard + '\'' +
        ", mainBoard='" + mainBoard + '\'' +
        ", power='" + power + '\'' +
        ", keyboard='" + keyboard + '\'' +
        ", mouse='" + mouse + '\'' +
        '}';
    }

    private Computer(Builder builder) {
        this.cpu = builder.cpu;
        this.memory = builder.memory;
        this.hardDisk = builder.hardDisk;
        this.videoCard = builder.videoCard;
        this.mainBoard = builder.mainBoard;
        this.power = builder.power;
        this.keyboard = builder.keyboard;
        this.mouse = builder.mouse;
    }

    public static class Builder {
        private String cpu;
        private String memory;
        private String hardDisk;
        private String videoCard;
        private String mainBoard;
        private String power;
        private String keyboard;
        private String mouse;

        public Builder cpu(String cpu) {
            this.cpu = cpu;
            return this;
        }

        public Builder memory(String memory) {
            this.memory = memory;
            return this;
        }

        public Builder hardDisk(String hardDisk) {
            this.hardDisk = hardDisk;
            return this;
        }

        public Builder videoCard(String videoCard) {
            this.videoCard = videoCard;
            return this;
        }

        public Builder mainBoard(String mainBoard) {
            this.mainBoard = mainBoard;
            return this;
        }

        public Builder power(String power) {
            this.power = power;
            return this;
        }

        public Builder keyboard(String keyboard) {
            this.keyboard = keyboard;
            return this;
        }

        public Builder mouse(String mouse) {
            this.mouse = mouse;
            return this;
        }

        public Computer build() {
            return new Computer(this);
        }
    }

}

public class Client {

    public static void main(String[] args) {
        Computer build = new Computer.Builder().memory("8GB").cpu("i7").hardDisk("1TB").keyboard("罗技").
        videoCard("GTX1660").power("500W").mouse("罗技").mainBoard("华硕").build();
        System.out.println(build);
    }
}

优势： 使用建造者模式构建实体类可以大大提升代码的可读性和可维护性，简化构造过程，灵活处理可选参数，并使得对象的创建过程更加清晰和可扩展 。