设计模式-建造者模式

什么是建造者模式

建造者模式是一种对象创建型设计模式。它允许您创建不同类型的复杂对象，而无需暴露其内部构造细节。

建造者模式的目的是将对象的构造过程分解为多个简单的步骤，从而使其更加可控和可定制。它通常用于创建复杂的对象，例如汽车、计算机等。

建造者模式由四个组成部分组成：

1. 产品类：它是要创建的对象。它通常包含多个属性和方法。

2. 抽象建造者类：它定义了创建产品的抽象接口。它包含一个构建方法，该方法将产品的属性设置为特定的值。

3. 具体建造者类：它实现抽象建造者接口，并提供了一个具体的构建方法。它通常包含一个与产品类相似的属性集合，并且使用这些属性来构建产品。

4. 指挥者类：它协调创建过程。它将抽象建造者传递给具体建造者，并使用抽象建造者的接口来构建产品。

建造者模式的示例

在本例中，我们将创建一个电脑对象。我们将使用建造者模式来创建电脑对象，并分解构造过程为多个简单的步骤。

产品类

我们的产品类是一个电脑对象。它包含以下属性：

• CPU

• 内存

• 硬盘

• 显示器

• 键盘

• 鼠标

publicclassComputer {
    privateStringcpu;
    privateStringmemory;
    privateStringhardDisk;
    privateStringmonitor;
    privateStringkeyboard;
    privatepublic class Computer {
    private String cpu;
    private String memory;
    private String hardDisk;
    private String monitor;
    private String keyboard;
    private String mouse;

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

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

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

    public void setMonitor(String monitor) {
        this.monitor = monitor;
    }

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

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

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

抽象建造者类

我们的抽象建造者类是一个电脑建造者。它定义了创建电脑对象的抽象接口。

public abstract class ComputerBuilder {
    protected Computer computer
        public void buildCPU(String cpu) {
        computer.setCpu(cpu);
        }

    public void buildMemory(String memory) {
        computer.setMemory(memory);
    }

    public void buildHardDisk(String hardDisk) {
        computer.setHardDisk(hardDisk);
    }

    public void buildMonitor(String monitor) {
        computer.setMonitor(monitor);
    }

    public void buildKeyboard(String keyboard) {
        computer.setKeyboard(keyboard);
    }

    public void buildMouse(String mouse) {
        computer.setMouse(mouse);
    }

    public Computer getComputer() {
        return computer;
    }
}

具体建造者类

我们的具体建造者类是一个台式电脑建造者。它实现了电脑建造者接口，并提供了一个具体的构建方法。

public class DesktopBuilder extends ComputerBuilder {
    public DesktopBuilder() {
        computer = new Computer();
    }

    @Override
    public void buildCPU(String cpu) {
        computer.setCpu("Desktop " + cpu);
    }

    @Override
    public void buildMemory(String memory) {
        computer.setMemory("Desktop " + memory);
    }

    @Override
    public void buildHardDisk(String hardDisk) {
        computer.setHardDisk("Desktop " + hardDisk);
    }

    @Override
    public void buildMonitor(String monitor) {
        computer.setMonitor("Desktop " + monitor);
    }

    @Override
    public void buildKeyboard(String keyboard) {
        computer.setKeyboard("Desktop " + keyboard);
    }

    @Override
    public void buildMouse(String mouse) {
        computer.setMouse("Desktop " + mouse);
    }
}

指挥者类

指挥者类是一个电脑组装工。它协调创建过程，并使用电脑建造者的接口来构建产品。

 public class ComputerAssembler {
    private ComputerBuilder computerBuilder;

    public ComputerAssembler(ComputerBuilder computerBuilder) {
        this.computerBuilder = computerBuilder;
    }

    public Computer getComputer() {
        return computerBuilder.getComputer();
    }

    public void assembleComputer() {
        computerBuilder.buildCPU("Intel i7");
        computerBuilder.buildMemory("16GB");
        computerBuilder.buildHardDisk("1TB");
        computerBuilder.buildMonitor("24-inch");
        computerBuilder.buildKeyboard("Wireless");
        computerBuilder.buildMouse("Wireless");
    }
}

使用建造者模式创建电脑对象

我们现在可以使用建造者模式来创建电脑对象。我们将创建一个台式电脑对象，并使用指挥者类来协调创建过程。

public class Main {
    public static void main(String[] args) {
        ComputerBuilder desktopBuilder = new DesktopBuilder();
        ComputerAssembler assembler = new ComputerAssembler(desktopBuilder);
        assembler.assembleComputer();
        Computer desktop = assembler.getComputer();
        System.out.println(desktop);
    }
}

输出：

Computer{cpu='Desktop Intel i7', memory='Desktop 16GB', hardDisk='Desktop 1TB', monitor='Desktop 24-inch', keyboard='Desktop Wireless', mouse='Desktop Wireless'}

使用建造者模式具有以下优点：

1. 更好的封装：建造者模式将对象构造过程分解为多个简单步骤，并将每个步

2. 更好的灵活性：由于建造者模式允许你构造复杂对象的多个部分，因此可以灵活地更改构造过程，以便适应不同的需求。

3. 更好的可维护性：由于建造者模式将构造过程分解为多个简单步骤，因此更容易理解和维护代码。

4. 更好的可扩展性：可以很容易地添加新的具体建造者类来创建不同类型的产品，而无需修改现有的代码。

建造者模式的缺点

使用建造者模式具有以下缺点：

1. 增加了代码的复杂性：建造者模式需要创建多个类来实现产品的构造过程，这可能会增加代码的复杂性。

2. 可能会导致性能问题：由于建造者模式创建了多个对象，因此可能会导致性能问题，特别是在创建大型对象时。

适用场景

建造者模式适用于以下场景：

1. 创建复杂对象：当需要创建复杂对象时，可以使用建造者模式，因为它允许你构造复杂对象的多个部分。

2. 需要更好的灵活性：当需要更好的灵活性来更改构造过程以适应不同的需求时，可以使用建造者模式。

3. 需要更好的可维护性：当需要更好的可维护性来理解和维护代码时，可以使用建造者模式。

4. 需要更好的可扩展性：当需要添加新的具体建造者类来创建不同类型的产品时，可以使用建造者模式。

总结

建造者模式是一种创建对象的设计模式，它允许你构造复杂对象的多个部分，并将这些部分组合成完整的对象。使用建造者模式可以提高代码的可维护性、可扩展性和灵活性，并使代码更易于理解。但是，建造者模式可能会增加代码的复杂性，并可能导致性能问题，特别是在创建大型对象时。建议在合适的场景下使用建造者模式来创建复杂对象。