23种设计模式之建造者模式（Builder Pattern）

本篇文章将23种设计模式中的建造者模式，此篇文章为一天学习一个设计模式系列文章，后面会分享其他模式知识。

小威要向诸佬学习呀

21584人浏览 · 2023-05-14 17:30:19

小威要向诸佬学习呀 · 2023-05-14 17:30:19 发布

前言：大家好，我是小威，24届毕业生，在一家满意的公司实习。本篇文章将23种设计模式中的建造者模式，此篇文章为一天学习一个设计模式系列文章，后面会分享其他模式知识。
如果文章有什么需要改进的地方还请大佬不吝赐教👏👏。
小威在此先感谢各位大佬啦~~🤞🤞
在这里插入图片描述

🏠个人主页：小威要向诸佬学习呀
🧑个人简介：大家好，我是小威，一个想要与大家共同进步的男人😉😉
目前状况🎉：24届毕业生，在一家满意的公司实习👏👏

💕欢迎大家：这里是CSDN，我总结知识的地方，欢迎来到我的博客，我亲爱的大佬😘

以下正文开始

在这里插入图片描述

建造者模式概念

建造者模式是一种创建型设计模式，它允许我们将一个复杂对象的构建步骤分离出来，使得同样的构建过程可以创建不同的表示。该模式的目的是将构建复杂对象的过程抽象化，从而减少代码的重复和复杂度。

在建造者模式中，我们通过Builder接口或抽象类定义了一个标准的构建流程，然后让不同的具体构造者按照这个标准来实现自己的构建流程。同时，我们还定义了一个指导者（Director）类，用于按照特定的顺序执行构建流程，从而完成对象的构建。

建造者模式优缺点

建造者模式的优点在于：

将构建复杂对象的过程封装起来，简化了代码结构和逻辑。
不同的具体构造者可以实现不同的构建流程，使得同样的构建过程可以创建不同的表示。
指导者类可以根据需要按照特定的顺序执行构建流程，从而达到更好的控制和管理对象的构建。

建造者模式的缺点在于：

添加新的部件需要修改抽象类和具体构造者的代码。
如果对象的属性较少，使用建造者模式可能会显得过于复杂，不如直接使用工厂方法模式或简单工厂模式。

总之，建造者模式适用于需要创建对象复杂且变化多端的情景，它能够将对象的构建过程标准化，从而达到代码重用和简化的目的。

建造者模式案例

首先我们创建一个电脑抽象类Computer和各个部件的抽象类Part，其中包含它们的基本属性及get和set方法。

public abstract class Computer {
    protected String mBoard;
    protected String mCpu;
    protected String mRam;
    protected String mHardDisk;

    public void setBoard(String board) {
        this.mBoard = board;
    }

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

    public void setRam(String ram) {
        this.mRam = ram;
    }

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

    public abstract String toString();
}

public abstract class Part {
    protected String mName;

    public void setName(String name) {
        this.mName = name;
    }

    public String getName() {
        return mName;
    }
}

然后我们定义一个Builder接口，包含构建各个部件的方法，如buildBoard、buildCpu等。

public interface Builder {
    void buildBoard(String board);
    void buildCpu(String cpu);
    void buildRam(String ram);
    void buildHardDisk(String hardDisk);
    Computer createComputer();
}

接着我们定义三种不同的具体构造者：AsusBuilder、DellBuilder和HPBuilder，它们分别实现了Builder接口，并且实现了构建各个部件的方法，根据不同的要求返回不同的部件对象。

public class AsusBuilder implements Builder {
    private Computer mComputer = new AsusComputer();

    @Override
    public void buildBoard(String board) {
        mComputer.setBoard(board);
    }

    @Override
    public void buildCpu(String cpu) {
        mComputer.setCpu(cpu);
    }

    @Override
    public void buildRam(String ram) {
        mComputer.setRam(ram);
    }

    @Override
    public void buildHardDisk(String hardDisk) {
        mComputer.setHardDisk(hardDisk);
    }

    @Override
    public Computer createComputer() {
        return mComputer;
    }
}

public class DellBuilder implements Builder {
    private Computer mComputer = new DellComputer();

    @Override
    public void buildBoard(String board) {
        mComputer.setBoard(board);
    }

    @Override
    public void buildCpu(String cpu) {
        mComputer.setCpu(cpu);
    }

    @Override
    public void buildRam(String ram) {
        mComputer.setRam(ram);
    }

    @Override
    public void buildHardDisk(String hardDisk) {
        mComputer.setHardDisk(hardDisk);
    }

    @Override
    public Computer createComputer() {
        return mComputer;
    }
}

public class HPBuilder implements Builder {
    private Computer mComputer = new HPComputer();

    @Override
    public void buildBoard(String board) {
        mComputer.setBoard(board);
    }

    @Override
    public void buildCpu(String cpu) {
        mComputer.setCpu(cpu);
    }

    @Override
    public void buildRam(String ram) {
        mComputer.setRam(ram);
    }

    @Override
    public void buildHardDisk(String hardDisk) {
        mComputer.setHardDisk(hardDisk);
    }

    @Override
    public Computer createComputer() {
        return mComputer;
    }
}

最后我们定义一个Director类，它含有一个Builder对象，以及按照固定的顺序执行构建流程的方法buildComputer。通过调用Director的buildComputer方法，我们便可以创建出一个完整的电脑对象。

public class Director {
    private Builder mBuilder;

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

    public void buildComputer(String board, String cpu, String ram, String hardDisk) {
        mBuilder.buildBoard(board);
        mBuilder.buildCpu(cpu);
        mBuilder.buildRam(ram);
        mBuilder.buildHardDisk(hardDisk);
    }
}

最后我们定义三个具体的电脑类AsusComputer、DellComputer和HPComputer，它们分别继承自Computer抽象类，实现了toString方法，用于打印电脑对象的属性。

public class AsusComputer extends Computer {
    @Override
    public String toString() {
        return "Asus Computer [Board=" + mBoard + ", CPU=" + mCpu + ", RAM=" + mRam + ", HardDisk="
                + mHardDisk + "]";
    }
}

public class DellComputer extends Computer {
    @Override
    public String toString() {
        return "Dell Computer [Board=" + mBoard + ", CPU=" + mCpu + ", RAM=" + mRam + ", HardDisk="
                + mHardDisk + "]";
    }
}

public class HPComputer extends Computer {
    @Override
    public String toString() {
        return "HP Computer [Board=" + mBoard + ", CPU=" + mCpu + ", RAM=" + mRam + ", HardDisk="
                + mHardDisk + "]";
    }
}

这样我们便完成了建造者模式的实现，可以通过下面的代码进行测试：

public class Client {
    public static void main(String[] args) {
        Builder asusBuilder = new AsusBuilder();
        Builder dellBuilder = new DellBuilder();

        Director director = new Director(asusBuilder);
        director.buildComputer("Asus Board", "Intel i7-8700K", "16GB DDR4", "1TB SSD");
        Computer asusComputer = asusBuilder.createComputer();
        System.out.println(asusComputer.toString());

        director = new Director(dellBuilder);
        director.buildComputer("Dell Board", "Intel Xeon E-2224G", "32GB DDR4", "2x 512Gb NVMe SSD");
        Computer dellComputer = dellBuilder.createComputer();
        System.out.println(dellComputer.toString());
    }
}

输出结果如下：

Asus Computer [Board=Asus Board, CPU=Intel i7-8700K, RAM=16GB DDR4, HardDisk=1TB SSD]
Dell Computer [Board=Dell Board, CPU=Intel Xeon E-2224G, RAM=32GB DDR4, HardDisk=2x 512Gb NVMe SSD]

好了，本篇文章就先分享到这里了，后续将会继续介绍23种设计模式之其他模式，感谢大佬认真读完支持咯~
在这里插入图片描述