设计模式——建造者模式-CSDN博客

本文链接：https://blog.csdn.net/pjymyself/article/details/121945038

建造者模式

建造者模式（Builder Pattern）使用多个简单的对象一步一步构建成一个复杂的对象。这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式。

一个 Builder 类会一步一步构造最终的对象。该 Builder 类是独立于其他对象的。

意图

将一个复杂的构建与其表示相分离，使得同样的构建过程可以创建不同的表示。

优点

封装性好，构建和表示分离
扩展性好，各个具体的建造者相互独立，有利于系统的解耦
客户端不必知道产品内部组成的细节，建造者可以对创建过程逐步细化，而不对其它模块产生任何影响，便于控制细节风险

缺点

产品的组成部分必须相同，这限制了其使用范围
如果产品的内部变化复杂，假设产品内部发生变化，则建造者也要同步修改，后期维护成本较大

建造者（Builder）模式 和 工厂（Factory）模式 的关注点不同：

建造者模式：注重零部件的组装过程
工厂方法模式：更注重零部件的创建过程

Tip：

二者可以结合使用

建造者的角色

建造者（Builder）模式的主要角色如下：

产品（Product）角色

一个具体的产品对象，它是包含多个组成部件的复杂对象，由具体建造者来创建其各个零部件。

抽象建造者（Builder）角色

它是一个包含创建产品（Product）各个子部件的抽象方法的接口

具体建造者（Concrete Builder）角色

实现 Builder 接口，完成复杂产品的各个部件的具体创建方法。

指挥者（Director）角色

它调用建造者对象中的部件构建与装配方法完成复杂对象的创建，在指挥中不涉及具体的产品信息。

以组装一台电脑作为例子，按建造者模式设计，如下图所示：

示例代码

按上图，组装一台电脑为例子，其相关类的代码如下：

产品角色

包含多个组成部件的复杂对象

package BuilderPattern;

/**
 * 建造者模式——产品
 *
 * （电脑）
 *
 */
public class Computer {

    private String cpu;             // 处理器
    private String graphicsCard;    // 显卡
    private String memory;          // 内存

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

    public void setGraphicsCard(String graphicsCard) {
        this.graphicsCard = graphicsCard;
    }

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

    public String getCpu() {
        return cpu;
    }

    public String getGraphicsCard() {
        return graphicsCard;
    }

    public String getMemory() {
        return memory;
    }
}

抽象建造者

包含创建产品各个子部件的抽象方法

package BuilderPattern;

/**
 * 建造者模式——抽象建造者
 *
 * （工程师）
 *
 */
public abstract class Engineer {

    // 创建产品对象
    protected Computer computer = new Computer();

    /**
     * 组装CPU
     */
    public abstract void buildCpu();

    /**
     * 组装显卡
     */
    public abstract void buildGraphicsCard();

    /**
     * 组装内存
     */
    public abstract void buildMemory();

    /**
     * 获取产品对象
     *
     * @return 产品
     */
    public Computer getComputer() {
        System.out.println("生产的电脑配置：");
        System.out.println("cpu "+computer.getCpu());
        System.out.println("显卡 "+computer.getGraphicsCard());
        System.out.println("内存 "+computer.getMemory());
        return computer;
    }
}

具体建造者

实现了抽象建造者接口

/**
 * 建造者模式——具体建造者
 *
 * （中级工程师）
 *
 */
public class IntermediateEngineer extends Engineer{
    @Override
    public void buildCpu() {
        computer.setCpu("i5");
    }

    @Override
    public void buildGraphicsCard() {
        computer.setGraphicsCard("MX330");
    }

    @Override
    public void buildMemory() {
        computer.setMemory("8G");
    }
}

/**
 * 建造者模式——具体建造者
 *
 * （高级工程师）
 */
public class SeniorEngineer extends Engineer{
    @Override
    public void buildCpu() {
        computer.setCpu("i7");
    }

    @Override
    public void buildGraphicsCard() {
        computer.setGraphicsCard("GTX1660");
    }

    @Override
    public void buildMemory() {
        computer.setMemory("16G");
    }
}

指挥者

调用建造者中的方法完成复杂对象的创建

/**
 * 建造者模式——指挥者
 *
 * （经理）
 *
 */
public class Manager {
    // 创建抽象建造者
    private Engineer engineer;

    /**
     * 构造函数-指定建造者
     * @param engineer
     */
    public Manager(Engineer engineer) {
        this.engineer = engineer;
    }

    /**
     * 指定建造者
     * @param engineer
     */
    public void setEngineer(Engineer engineer) {
        this.engineer = engineer;
    }

    /**
     * 产品构建与组装方法
     * @return
     */
    public Computer build() {
        engineer.buildCpu();
        engineer.buildGraphicsCard();
        engineer.buildMemory();
        return engineer.getComputer();
    }
}

客户端

/**
 * 建造者模式
 *
 */
public class BuilderPatternDemo {

    public static void main(String[] args) {
        // 创建具体建造者对象（高级工程师）
        Engineer engineer = new SeniorEngineer();
        // 创建指挥者对象，并指定指挥者使用所创建的建造者
        Manager manager = new Manager(engineer);
        // 指挥者指挥建造者（高级工程师）生产
        Computer computer = manager.build();

        System.out.println();
        // 指挥另一个建造者（中级工程师）生产
        engineer = new IntermediateEngineer();
        manager.setEngineer(engineer);
        computer = manager.build();
    }
    
}

执行结果