建造者模式

建造者模式（Builder Pattern）是一种创建型设计模式，它用于分步骤地创建复杂对象，而无需直接调用构造函数。通过将对象的构建过程与其表示（即对象内部细节的实现）分离，建造者模式允许创建不同的对象表示，同时保持构造过程的一致性。

特点

• 分步骤创建：建造者模式将对象的创建过程分解为多个步骤，允许逐步设置对象的各个部分（例如，属性或组件）。
• 可读性：由于每一步都明确设置某个属性，建造者模式使得代码更加清晰，便于理解和维护。
• 可变性：同样的构造过程可以用于创建不同类型或不同配置的对象，满足多样化需求。
• 封装性：构建过程和最终产品的实现细节被隐藏，使用者不需要关心对象的创建细节，只需按照步骤进行配置。

原理

建造者模式通常涉及以下几个组件：

• Builder（建造者）：提供用于构建对象不同部分的方法，通常采用链式调用，允许设置对象的属性或组件。
• Concrete Builder（具体建造者）：实现 Builder 接口，提供具体的步骤来构建对象的各个部分。
• Product（产品）：最终构建的复杂对象，它由多个部分组成。
• Director（指导者，可选）：负责管理构建过程的顺序，调用 Builder 的方法一步步创建对象。

实现

//产品
public class Computer {
    private String CPU;
    private String GPU;
    private int RAM;
    private int storage;
    private PeripheralDevice peripheralDevice;
    private Computer(){}
    @Override
    public String toString() {
        return "Computer " +
                "[CPU=" + CPU
                + ", GPU=" + GPU
                + ", RAM=" + RAM
                + "GB, storage=" + storage + "GB]"
                + " -- "
                + "PeripheralDevice [" + ((peripheralDevice==null)?"null":peripheralDevice.toString())
                + "]";
    }
    
    //建造者类
    public static class ComputerBuilder {
        Computer c=new Computer();
        public ComputerBuilder setCPU(String CPU) {
            c.CPU = CPU;
            return this;
        }

        public ComputerBuilder setGPU(String GPU) {
            c.GPU = GPU;
            return this;
        }

        public ComputerBuilder setRAM(int RAM) {
            c.RAM = RAM;
            return this;
        }

        public ComputerBuilder setStorage(int storage) {
            c.storage = storage;
            return this;
        }
        //添加外设
        public ComputerBuilder setPeripheralDevice(String indicator,String mouse,String keyboard){
            c.peripheralDevice=new PeripheralDevice(indicator,mouse,keyboard);
            return this;
        }
        public Computer build() {
            return c;
        }
    }
}
//在不改变computer类的情况下添加外设类，也算产品类
class PeripheralDevice{
    private String indicator;
    private String mouse;
    private String keyboard;
//    public PeripheralDevice(){}
    public PeripheralDevice(String indicator, String mouse, String keyboard){
        this.indicator=indicator;
        this.mouse=mouse;
        this.keyboard=keyboard;
    }
    @Override
    public String toString() {
        return "PeripheralDevice{" +
                "indicator='" + indicator + '\'' +
                ", mouse='" + mouse + '\'' +
                ", keyboard='" + keyboard + '\'' +
                '}';
    }
}
//test
//建造者模式 (Builder)
public class TestBuilder {
    public static void main(String[] args) {
        Computer gamingPC = new Computer.ComputerBuilder()
                .setCPU("Intel Core i9")
                .setGPU("NVIDIA RTX 3080")
                .setRAM(32)
                .setStorage(1024)
                .build();

        Computer officePC = new Computer.ComputerBuilder()
                .setCPU("Intel Core i5")
                .setGPU("Integrated Graphics")
                .setRAM(16)
                .setStorage(512)
                .setPeripheralDevice("leisheng","leisheng","leisheng")
                .build();
        System.out.println(gamingPC);
        System.out.println(officePC);

    }
}

优缺点

优点：

• 简化复杂对象的创建：通过分步骤创建，避免了庞大的构造函数，提升了代码的可读性。
• 灵活性：支持多种不同配置的对象创建，适应不同需求。
• 易于扩展：可以轻松添加新的构建步骤或不同类型的产品，而不影响现有代码。

缺点：

• 过度设计的风险：如果对象不够复杂，使用建造者模式可能显得过于繁琐。
• 额外代码：需要编写更多的类和方法，可能会增加代码量。

适用场景

• 对象构造过程复杂且包含多个步骤。
• 需要创建的对象具有不同的表示或配置。
• 需要确保对象的创建过程是可控且逐步进行的。

总结

建造者模式特别适合需要灵活构造过程的复杂对象，如配置复杂的电脑、创建具有多个可选参数的类实例等。