Java建造者模式：创建复杂对象的灵活构建者

在软件开发中，我们经常遇到需要创建一个复杂对象的情况。如果使用传统的构造函数进行对象创建，可能会导致构造函数参数过多，难以管理和维护。建造者模式（Builder Pattern）通过引入建造者对象来逐步构建复杂对象，使得对象的构建过程更加灵活、可控，同时还能提供更好的代码可读性和维护性。

一、原理

建造者模式的核心思想是将一个复杂对象的构建过程与它的表示分离，使得同样的构建过程可以创建不同的表示。具体来说，建造者模式通过将对象的构建过程委派给不同的建造者类，每个建造者类都负责创建对象的一部分，并最终将这些部分组装成完整的对象。

它由四个主要的角色组成：产品类（Product）、抽象建造者类（Builder）、具体建造者类（ConcreteBuilder）和指导者类（Director）

产品类（Product）：表示最终构建的对象。该类具有一些属性，可以通过设置相应的setter方法进行赋值，并且定义了一个展示产品的方法。
抽象建造者类（Builder）：定义了产品构建的抽象方法。包括构建不同部分的方法和获取最终产品的方法，由具体建造者类来实现。
具体建造者类（ConcreteBuilder）：继承自抽象建造者类，实现了具体的构建过程。包括构建不同部分和获取最终产品的方法。
指导者类（Director）：负责使用具体的建造者类来构建产品。通过调用具体建造者的方法来完成产品的构造，并最终返回一个完整的产品对象。

产品类

public class Product {
    private String partA;
    private String partB;
    private String partC;

    public void setPartA(String partA) {
        this.partA = partA;
    }

    public void setPartB(String partB) {
        this.partB = partB;
    }

    public void setPartC(String partC) {
        this.partC = partC;
    }

    public void show() {
        System.out.println("Product: " + partA + ", " + partB + ", " + partC);
    }
}

抽象建造者类

public abstract class Builder {
    public abstract void buildPartA();
    public abstract void buildPartB();
    public abstract void buildPartC();
    public abstract Product buildProduct();
}

具体建造者类

public class ConcreteBuilder extends Builder {
   private Product product = new Product();

    @Override
    public void buildPartA() {
        product.setPartA("生产线1>>>-------->产品A");
    }

    @Override
    public void buildPartB() {
        product.setPartB("生产线1>>>-------->产品B");
    }

    @Override
    public void buildPartC() {
        product.setPartC("生产线1>>>-------->产品C");
    }

    @Override
    public Product buildProduct() {
        return product;
    }
}

指导者类

public class Director {
   public Builder construct(Builder builder) {
        builder.buildPartA();
        builder.buildPartB();
        builder.buildPartC();
        return builder;
    }
}

测试

public class Client {
    public static void main(String[] args) {
        // 指导者
        Director director = new Director();
        // 生产线1
        Builder construct = director.construct(new ConcreteBuilder());
        Product product = construct.buildProduct();

        // 显示生产了什么产品
        product.show();
    }
}

运行结果如下:

观察代码，可以发现建造者模式的流程如下：

第一步，创建指导者(Director)对象和具体建造者(ConcreteBuilder)对象来开始构建创建过程。
第二步，指导者(Director)对象根据具体的建造者类完成建造过程，调用具体建造者的方法来构建产品的各个部分。也就是其方法中的builder.buildPartA(); builder.buildPartB(); builder.buildPartC();
建造者将构建好的部分返回给指导者。
指导者最终返回一个完整的产品对象，供客户端使用。

也就说，Product这个类属性的创建，不由它自身来控制，而是由具体的指导者(Director)对象来控制

那这样感觉把一个对象的创建变得复杂化了，为什么这么做呢? 这么做有什么好处和坏处呢??

优点：