设计模式_建造者模式_Builder

已于 2024-08-13 11:40:50 修改
阅读量977 收藏 15
点赞数 21
CC 4.0 BY-SA版权
分类专栏： 设计模式 文章标签： 设计模式 建造者模式 java
于 2024-01-18 09:05:11 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_39977988/article/details/135617896
本文详细介绍了建造者模式的概念、应用场景及实现方式，通过对比不同实现方案，展示了如何利用建造者模式分离产品和构建过程，实现灵活的对象创建。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

介绍

  • 建造者模式又叫生成器模式，是一种对象构建模式。它可以将复杂对象的建造过程抽象出来(抽象类别)，使这个抽象过程的不同实现方法可以构造出不同属性的对象
  • 建造者模式是一步一步创建一个复杂的对象，它允许用户只通过指定复杂对象的类型和内容就可以构建它们，不需要知道内部的具体构建细节（如用户在选购汽车的时候，只需要选择好方向盘、轮胎、发动机类型，不需要知道零件是怎么制造出来的）

出场角色

在这里插入图片描述

  • Product（产品）：一个具体的产品对象
  • Builder (抽象建造者): 创建指定Product对象的各个部件的接口/抽象类，用于将建造流程整理出来，但是不在乎建造细节，即只声明抽象方法
  • ConcreteBuilder (具体建造者): 实现抽象建造者的接口
  • Director（指挥者/监工）: 使用Builder接口来生成示例。它主要是用于创建一个复杂的对象。它主要有两个作用，一是隔离客户与对象的生产过程，二是控制产品对象的生产过程。
  • Client（使用者）：让Director干活，使用建造者模式

案例

盖房子需求

房子有多种类型，比如普通房，高楼，别墅，建房子的过程包括打桩、砌墙、封顶多个步骤，不同类型的房子建造的流程差不多，但是里面的方法有所差异

原始实现

在这里插入图片描述

【抽象房子类】

package com.atguigu.builder;

public abstract class AbstractHouse {

/**
* 打地基
*/
public abstract void buildBasic();

/**
* 砌墙
*/
public abstract void buildWalls();

/**
* 封顶
*/
public abstract void roofed();

public void build() {
  buildBasic();
  buildWalls();
  roofed();
}

}

【普通房子】

package com.atguigu.builder;

public class CommonHouse extends AbstractHouse {

@Override
public void buildBasic() {
  System.out.println(" 普通房子打地基 ");
}

@Override
public void buildWalls() {
  System.out.println(" 普通房子砌墙 ");
}

@Override
public void roofed() {
  System.out.println(" 普通房子封顶 ");
}

}

【高楼】

package com.atguigu.builder;

public class HignBuilding extends AbstractHouse {

@Override
public void buildBasic() {
  System.out.println(" 高楼打地基 ");
}

@Override
public void buildWalls() {
  System.out.println(" 高楼房子砌墙 ");
}

@Override
public void roofed() {
  System.out.println(" 高楼房子封顶 ");
}

}

【主类】

package com.atguigu.builder;

public class Client {

public static void main(String[] args) {
  CommonHouse commonHouse = new CommonHouse();
  commonHouse.build();
  System.out.println("-------------------------------------------------------------------------------------------------------");
  HignBuilding highBuilding = new HignBuilding();
  highBuilding.build();
}

}

【运行】

普通房子打地基 
普通房子砌墙 
普通房子封顶 
-------------------------------------------------------------------------------------------------------
高楼打地基 
高楼房子砌墙 
高楼房子封顶 

Process finished with exit code 0
分析
  • 优点：比较好理解，简单易操作
  • 缺点：程序结构过于简单，没有设计缓存层对象，程序的扩展和维护不好。这种设计方案，把产品(即:房子) 和 创建产品的过程(即:建房子流程) 封装在一起，耦合性增强了
  • 改进：使用建造者模式，将产品和产品建造过程解耦
建造者模式

在这里插入图片描述

【抽象房子】

package com.atguigu.builder.improve;

/**
* 产品->Product
*/
public class House {
private String basic;
private String wall;
private String roofed;

public String getBasic() {
    return basic;
}

public void setBasic(String basic) {
    this.basic = basic;
}

public String getWall() {
    return wall;
}

public void setWall(String wall) {
    this.wall = wall;
}

public String getRoofed() {
    return roofed;
}

public void setRoofed(String roofed) {
    this.roofed = roofed;
}

public House(String basic, String wall, String roofed) {
    this.basic = basic;
    this.wall = wall;
    this.roofed = roofed;
}

public House() {
}

@Override
public String toString() {
    return "House{" +
            "basic='" + basic + '\'' +
            ", wall='" + wall + '\'' +
            ", roofed='" + roofed + '\'' +
            '}';
}
}

【抽象建造者】

package com.atguigu.builder.improve;


/**
* 抽象的建造者
*/
public abstract class HouseBuilder {
/**
* 组合House
*/
protected House house = new House();

//-------------------------将建造的流程写好--------------------------

/**
* 打地基
*/
public abstract void buildBasic();

/**
* 砌墙
*/
public abstract void buildWalls();

/**
* 封顶
*/
public abstract void roofed();

/**
* 建造好房子后将产品(房子) 返回
* @return
*/
public House buildHouse() {
  return house;
}

}

【具体建造者：普通房】

package com.atguigu.builder.improve;

/**
* 具体建造者
*/
public class CommonHouse extends HouseBuilder {

@Override
public void buildBasic() {
  System.out.println(" 普通房子打地基5米 ");
  super.house.setBasic("地基5米");
}

@Override
public void buildWalls() {
  System.out.println(" 普通房子砌墙10cm ");
  super.house.setWall("墙10cm");
}

@Override
public void roofed() {
  System.out.println(" 普通房子屋顶 ");
  super.house.setRoofed("普通房子屋顶");
}

}

【具体建造者：高楼】

package com.atguigu.builder.improve;

/**
* 具体建造者
*/
public class HighBuilding extends HouseBuilder {

@Override
public void buildBasic() {
  System.out.println(" 高楼的打地基100米 ");
  super.house.setBasic("地基100米");
}

@Override
public void buildWalls() {
  System.out.println(" 高楼的砌墙20cm ");
  super.house.setWall("墙20cm");
}

@Override
public void roofed() {
  System.out.println(" 高楼的透明屋顶 ");
  super.house.setRoofed("透明屋顶");
}

}

【指挥者】

package com.atguigu.builder.improve;

/**
* 指挥者，调用制作方法，返回产品
*/
public class HouseDirector {
/**
* 聚合
*/
HouseBuilder houseBuilder = null;

/**
* 方式一：构造器传入 houseBuilder
* @param houseBuilder
*/
public HouseDirector(HouseBuilder houseBuilder) {
  this.houseBuilder = houseBuilder;
}

/**
* 方式二：通过setter 传入 houseBuilder
* @param houseBuilder
*/
public void setHouseBuilder(HouseBuilder houseBuilder) {
  this.houseBuilder = houseBuilder;
}

/**
* 指挥者统一管理建造房子的流程
* @return
*/
public House constructHouse() {
  houseBuilder.buildBasic();
  houseBuilder.buildWalls();
  houseBuilder.roofed();
  return houseBuilder.buildHouse();
}
}

【客户端】

package com.atguigu.builder.improve;

public class Client {
public static void main(String[] args) {

    ///盖普通房子
    //准备创建房子的指挥者
    HouseDirector houseDirector = new HouseDirector(new CommonHouse());
    //完成盖房子，返回产品(普通房子)
    House commonHouse = houseDirector.constructHouse();
    System.out.println("普通房子：" + commonHouse.toString());

    System.out.println("---------------------------------------------------------------------------------------------");
    ///盖高楼
    //重置建造者，改成修高楼
    houseDirector.setHouseBuilder(new HighBuilding());
    //完成盖房子，返回产品(高楼)
    House highBuilding = houseDirector.constructHouse();
    System.out.println("高楼：" + highBuilding.toString());
}
}

【运行】

普通房子打地基5米 
普通房子砌墙10cm 
普通房子屋顶 
普通房子：House{basic='地基5米', wall='墙10cm', roofed='普通房子屋顶'}
---------------------------------------------------------------------------------------------
高楼的打地基100米 
高楼的砌墙20cm 
高楼的透明屋顶 
高楼：House{basic='地基100米', wall='墙20cm', roofed='透明屋顶'}

Process finished with exit code 0

文档编写

在这里插入图片描述

【抽象建造者】

package com.atguigu.builder.Sample;

public abstract class Builder {
/**
 * 编写标题
 * @param title
 */
public abstract void makeTitle(String title);

/**
 * 编写字符串
 * @param str
 */
public abstract void makeString(String str);

/**
 * 编写条目
 * @param items
 */
public abstract void makeItems(String[] items);

/**
 * 完成文档编写
 */
public abstract void close();
}

【具体建造者一】

package com.atguigu.builder.Sample;

import java.io.FileWriter;
import java.io.IOException;
import java.io.PrintWriter;

public class HTMLBuilder extends Builder {
/**
 * 文件名
 */
private String filename;
/**
 * 用于编写文件的PrintWriter
 */
private PrintWriter writer;

/**
 * HTML文件的标题
 *
 * @param title
 */
public void makeTitle(String title) {
    // 将标题作为文件名
    filename = title + ".html";
    try {
        // 生成 PrintWriter
        writer = new PrintWriter(new FileWriter(filename));
    } catch (IOException e) {
        e.printStackTrace();
    }
    // 输出标题
    writer.println("<html><head><title>" + title + "</title></head><body>");
    writer.println("<h1>" + title + "</h1>");
}

/**
 * HTML文件中的字符串
 *
 * @param str
 */
public void makeString(String str) {
    // 用<p>标签输出
    writer.println("<p>" + str + "</p>");
}

/**
 * HTML文件中的条目
 *
 * @param items
 */
public void makeItems(String[] items) {
    // 用<ul>和<li>输出
    writer.println("<ul>");
    for (int i = 0; i < items.length; i++) {
        writer.println("<li>" + items[i] + "</li>");
    }
    writer.println("</ul>");
}

/**
 * 完成文档
 */
public void close() {
    // 关闭标签
    writer.println("</body></html>");
    // 关闭文件
    writer.close();
}

public String getResult() {
    // 编写完成的文档
    return filename;
}
}

【具体建造者二】

package com.atguigu.builder.Sample;

public class TextBuilder extends Builder {
/**
 * 文档内容保存在该字段中
 */
private StringBuffer buffer = new StringBuffer();

/**
 * 纯文本的标题
 *
 * @param title
 */
public void makeTitle(String title) {
    // 装饰线
    buffer.append("==============================\n");
    // 为标题添加『』
    buffer.append("『" + title + "』\n");
    // 换行
    buffer.append("\n");
}

/**
 * 纯文本的字符串
 *
 * @param str
 */
public void makeString(String str) {
    // 为字符串添加■
    buffer.append('■' + str + "\n");
    // 换行
    buffer.append("\n");
}

/**
 * 纯文本的条目
 *
 * @param items
 */
public void makeItems(String[] items) {
    for (int i = 0; i < items.length; i++) {
        // 为条目添加・
        buffer.append("　・" + items[i] + "\n");
    }
    // 换行
    buffer.append("\n");
}

/**
 * 完成文档
 */
public void close() {
    // 装饰线
    buffer.append("==============================\n");
}

/**
 * 完成的文档
 * @return
 */
public String getResult() {
    // 将StringBuffer变换为String
    return buffer.toString();
}
}

【指挥者】

package com.atguigu.builder.Sample;

/**
* 由于TextBuilder和HTMLBuilder都是Builder的子类，因此Director 仅仅使用Builder的方法即可编写文档。
* Director并不关心实际编写文档的到底是TextBuilder还是HTMBuilder
*/
public class Director {
private Builder builder;

/**
 * 实际上不会将 Builder类的实例作为参数传递给 Director类。这是因为 Builder 类是抽象类，是无法生成其实例的。
 * 实际上传递给 Director 类的是 Builder类的子类
 * @param builder
 */
public Director(Builder builder) {
    this.builder = builder;
}

/**
 * 编写文档
 */
public void construct() {
    // 标题
    builder.makeTitle("Greeting");
    // 字符串
    builder.makeString("从早上至下午");
    // 条目
    builder.makeItems(new String[]{
            "早上好。",
            "下午好。",
    });
    // 其他字符串
    builder.makeString("晚上");
    // 其他条目
    builder.makeItems(new String[]{
            "晚上好。",
            "晚安。",
            "再见。",
    });
    // 完成文档
    builder.close();
}
}

【测试】

package com.atguigu.builder.Sample;

/**
* Builder模式测试
*/
public class Main {
public static void main(String[] args) {
    String type = "plain";
    if (type.equals("plain")) {
        TextBuilder textbuilder = new TextBuilder();
        Director director = new Director(textbuilder);
        director.construct();
        String result = textbuilder.getResult();
        System.out.println(result);
    } else if (type.equals("html")) {
        HTMLBuilder htmlbuilder = new HTMLBuilder();
        Director director = new Director(htmlbuilder);
        director.construct();
        String filename = htmlbuilder.getResult();
        System.out.println(filename + "文件编写完成。");
    } else {
        usage();
        System.exit(0);
    }
}

public static void usage() {
    System.out.println("Usage: java Main plain      编写纯文本文档");
    System.out.println("Usage: java Main html       编写HTML文档");
}
}

【运行】

type= “plain”

==============================
『Greeting』

■从早上至下午

　・早上好。
　・下午好。

■晚上

　・晚上好。
　・晚安。
　・再见。

==============================


Process finished with exit code 0

type = “html”

<html>
<head><title>Greeting</title></head>
<body>
<h1>Greeting</h1>
<p>从早上至下午</p>
<ul>
<li>早上好。</li>
<li>下午好。</li>
</ul>
<p>晚上</p>
<ul>
<li>晚上好。</li>
<li>晚安。</li>
<li>再见。</li>
</ul>
</body>
</html>

【分析】

  • Main类并不知道Builder类，它只是调用了Direct 类的construct 方法这样，Director类就会开始工作(Main类对此一无所知)，并完成文档的编写
  • Director类知道Builder类，它调用Builder类的方法来编写文档，但它并不知道它所使用的类到底是 TextBuilder类、HTMLBuilder类还是其他 Builder类的子类，而且也没有必要知道，因为Director类只使用Builder类的方法
  • 不论是将 TextBuilder 的实例传递给 Director，还是将HTMLBuilder类的实例传递给 Director，它都可以正常工作，原因正是Director类不知道Builder类的具体的子类。正是因为不知道才能够替换，正是因为可以替换，组件才具有高价值。作为设计人员，我们必须时刻关注这种“可替换性”
拓展一

【要求】

请修改 Builder类TetBuilder类和HTMLBuilder类，确保“在调用makeString 方法、makeItems 方法和close方法之前必须且只能调用一次makeTitle方法”

【Builder 类】

public abstract class Builder {
private boolean initialized = false;
public void makeTitle(String title) {
    if (!initialized) {
        buildTitle(title);
        initialized = true;
    }
}
public void makeString(String str) {
    if (initialized) {
        buildString(str);
    }
}
public void makeItems(String[] items) {
    if (initialized) {
        buildItems(items);
    }
}
public void close() {
    if (initialized) {
        buildDone();
    }
}
protected abstract void buildTitle(String title);
protected abstract void buildString(String str);
protected abstract void buildItems(String[] items);
protected abstract void buildDone();
}

【其他两个类】

其他两个类的方法内容还是一样的，修改一下方法名，将抽象Builder的方法实现即可

问题

问：编写的文档被保存在了buffer字段中，但buffer字段并非是String类型的，而是StringBuffer类型的，请问是为什么呢?如果使用了 string 类型会有什么问题呢?

答：使用String类型保存文档会存在效率问题，因为String类型是不可变的，每次对String进行修改都会生成一个新的String对象，而StringBuffer类型是可变的，可以进行高效的字符串拼接和修改。因此，为了保证文档的高效修改和拼接，使用StringBuffer类型更加合适

JDK源码中使用建造者模式

在这里插入图片描述
在这里插入图片描述

  • Appendable 接口定义了多个append方法(抽象方法)，即Appendable 为抽象建造者，定义了抽象方法
  • AbstractStringBuilder 实现了 Appendable 接口方法，这里的AbstractStringBuilder 已经是建造者，只是不能实例化
  • StringBuilder 即充当了指挥者角色，同时充当了具体的建造者，建造方法的实现是由 AbstractStringBuilder 完成，而StringBuilder 继承了AbstractStringBuilder

在这里插入图片描述

【总结】

  • JDK中使用设计模式的方式不一定和标准的一样（设计模式可能是更后面提出来的），但是核心思想大同小异

注意事项

  • 客户端（使用程序）不必知道产品内部组成的细节，将产品本身与产品的创建过程解耦，使得相同的创建过程可以创建不同的产品对象
  • 每一个具体建造者都相对独立，而与其他的具体建造者无关，因此可以很方便地替换具体建造者或增加新的具体建造者， 用户使用不同的具体建造者即可得到不同的产品对象
  • 可以更加精细地控制产品的创建过程。将复杂产品的创建步骤分解在不同的方法中，使得创建过程更加清晰，也更方便使用程序来控制创建过程
  • 增加新的具体建造者无须修改原有类库的代码，指挥者类针对抽象建造者类编程系统扩展方便，符合“开闭原则“
  • 建造者模式所创建的产品一般具有较多的共同点，其组成部分相似，如果产品之间的差异性很大，则不适合使用建造者模式，因此其使用范围受到一定的限制
  • 如果产品的内部变化复杂，可能会导致需要定义很多具体建造者类来实现这种变化导致系统变得很庞大，因此在这种情况下，要考虑是否选择建造者模式

【抽象工厂模式vs建造者模式】

  • 抽象工厂模式实现对产品家族的创建，一个产品家族是这样的一系列产品: 具有不同分类维度的产品组合，采用抽象工厂模式不需要关心构建过程，只关心什么产品由什么工厂生产即可
  • 建造者模式则是要求按照指定的蓝图建造产品，它的主要目的是通过组装零配件而产生一个新产品
  • 两种模式都用来生成复杂的实例
C++设计模式——Builder Pattern建造者模式
程序员与背包客_CoderZ
09-12 2101
建造者模式，又被称为生成器模式，是一种创建型设计模式，它将复杂产品的构建过程分解为一系列简单的步骤，每个步骤由独立的建造者对象负责。建造者模式常用于创建复杂的对象，它避免了直接传递大量参数来构造函数，使得构建过程变得可控，让代码变得灵活和可维护。建造者模式允许开发者按照指定的步骤创建复杂对象，构建过程的细节被封装在具体建造者中，将创建对象的过程和表示对象的过程分离，且同一个构建过程可以使用不同的具体建造者以及不同的顺序来创建不同的表示。
【设计模式】——建造者模式（Builder Pattern）
J^T的博客
08-05 1212
建造者模式的核心思想是将一个复杂对象的构建过程与它的表示分离，使得同样的构建过程可以创建出不同的表示。它允许用户通过指定复杂对象的类型和内容来构建它们，而无需知道对象内部的具体构建细节。建造者模式隐藏了复杂对象的创建细节，通过一步一步构建一个复杂的对象，使得构建过程更加清晰和易于控制。
设计模式——建造者
hello_haozi的专栏
08-25 1万+
最近的心得，我发现学一门设计模式，不管你是否能立刻理解它，第一最要紧的是要记住两个东西。1、它是属于什么范畴的设计模式。2、记住UML图。这两个是打开这个设计模式之门的金钥匙！为什么这么讲？因为刚刚学新的设计模式，如果一味的埋头在文字中，思想中，代码编写的例子中，如果你这个设计模式又不是看的很懂，实在是会让人晕头转向看的吐血身亡。结果在身亡前，你都不知道这个设计模式干什么用，也不知该怎么去写。心得
设计模式：建造者模式（Builder）
weixin_34121304的博客
03-25 912
 建造者模式：是将一个复杂的对象的构建与它的表示分离，使得同样的构建过程可以创建不同的表示。  建造者模式通常包括下几个角色： 1. builder（抽象建造者）：给出一个抽象结论，以规范产品对象的各个组成成分的建造。这个接口规定要实现复杂对象的那些部分的创建，并不涉及具体的对象部件的创建。 2. ConcreteBuilder...
设计模式（三）建造者模式Builder（创建型）
weixin_30547797的博客
04-27 509
设计模式（三）建造者模Builder（http://blog.csdn.net/hguisu/article/details/7518060） 1. 概述 在软件开发的过程中，当遇到一个“复杂的对象”的创建工作，该对象由一定各个部分的子对象用一定的算法构成，由于需求的变化，复杂对象的各个部分经常面临剧烈的变化，但将它们组合在一起的算法相对稳定。 例子1：...
【设计模式——学习笔记】23种设计模式——建造者模式Builder（原理讲解+应用场景介绍+案例介绍+Java代码实现）
我只管埋头前行，剩下的交给时间。
07-22 1万+
讲解建造者模式的思想，介绍其常见的应用场景，举例说明建造者模式的实现方式
设计模式—建造者模式
aiganxie2129的博客
02-20 192
建造者模式（Builder Pattern）使用多个简单的对象一步一步构建成一个复杂的对象。 意图：将一个复杂的构建与其表示相分离，使得同样的构建过程可以创建不同的表示。 主要解决：主要解决在软件系统中，有时候面临着"一个复杂对象"的创建工作，其通常由各个部分的子对象用一定的算法构成；由于需求的变化，这个复杂对象的各个部分经常面临着剧烈的变化，但是将它们组合在一起的算法却相对稳...
php设计模式 Builder(建造者模式)
12-19
**PHP设计模式：Builder(建造者模式)** 建造者模式是一种创建型设计模式，它将一个复杂对象的构造过程与其表示分离，使得同样的构建过程可以创建不同的表示。在PHP中，这种模式允许我们通过相同的构建步骤来创建...
java设计模式-建造者模式(Builder Pattern)
最新发布
11-26
建造者模式是软件工程中的一种设计模式，其主要目的是为了应对创建复杂对象的过程，通过将对象的构造与表示分离，使用一个构建器类来逐步构建最终对象。这种模式的优点在于能够提高代码的灵活性和可维护性，同时也...
Java设计模式之建造者模式（Builder模式）介绍
09-03
Java设计模式中的建造者模式（Builder模式）是一种创建型设计模式，它的主要目的是将对象的构建过程和表示分离开来，使构建过程更加灵活，同时允许相同构建过程创建不同的表示形式。这种模式常用于创建复杂对象，...
设计模式：建造者模式（ Builder ）
平什么阿的博客
05-09 604
文章目录1. 盖房子需求2. 传统方式3. 建造者模式3.1 House 定义产品3.2 HouseBuilder 抽象建造者3.3 CommonHouse 抽象建造者的实现13.4 CommonHouse 抽象建造者的实现23.5 HouseDirector 指挥盖房子流程3.6 client 客户端调用4. 建造者模式在 JDK 的应用和源码分析5. 建造者模式的注意事项和细节 建造者模式（ Builder Pattern ） 又叫生成器模式，是一种对象构建。它可以将复杂对象的建造过程抽出来（类别）
【java设计模式】之 建造者（Builder）模式
武哥聊编程
05-06 1万+
        我们还是举上一节的例子：生产汽车。上一节我们通过模板方法模式控制汽车跑起来的动作，那么需求是无止境的，现在如果老板又增加了额外的需求：汽车启动、停止、鸣笛引擎声都由客户自己控制，他想要什么顺序就什么顺序，那该如何做呢？ 1. 汽车无休止的改造         假如现在要生产两种车，奔驰和宝马，这两辆车都有共性，我们所需要关注的是单个车的运行过程，这才是老板所关心的点所在。我们先...
建造者模式 (Builder)
weixin_34313182的博客
10-13 144
建造者模式 建造者模式（Builder Pattern）使用多个简单的对象一步一步构建成一个复杂的对象。这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式。 一个 Builder 类会一步一步构造最终的对象。该 Builder 类是独立于其他对象的。 介绍 意图：将一个复杂的构建与其表示相分离，使得同样的构建过程可以创建不同的表示。 主要解决：主要解决在软件系统中，有时候面临着"一个...
设计模式之建造者设计模式
weixin_34323858的博客
09-19 110
这是设计模式系列的第二篇——建造者设计模式，我希望推送的文章是一个系列的，尽量保持一样的写作风格，尽量把我理解的阐述清楚，关于建造者设计模式主要从以下几个方面来学习，具体如下： 概述 本质 关键概念 具体实现 总结 概述 建造者设计模式(Builder Pattern)属于创建型设计模式，主要用于创建复杂的对象，可将复杂对象的构建过程抽象出来，通...
一天一个设计模式(三) - 建造者模式(Builder)
weixin_34239592的博客
07-13 184
前言 建造模式是对象的创建模式。建造模式可以将一个产品的内部表象(internal representation)与产品的生产过程分割开来，从而可以使一个建造过程生成具有不同的内部表象的产品对象。 (一). 产品的内部表象 一个产品常有不同的组成成分作为产品的零件，这些零件有可能是对象，也有可能不是对象，他们通常又称为产品的内部表象(internal representation)。 (二). ...
设计模式第10讲——建造者模式（Builder）
热门推荐
让~学习~成为一种习惯（橡 皮 人の技术博客）
06-13 1万+
建造者模式是一种创建型设计模式，也叫生成器模式。一、什么是建造者模式 二、角色组成 三、优缺点 四、应用场景4.1 生活场景4.2 java场景 五、代码实现5.0 UML类图5.1 产品类（Product）5.2 抽象建造者（Builder）5.3 具体构建者（ConcreteBuilder）5.4 指导者（Director）5.5 testBuilder六、总结
设计模式之建造者（Builder）模式
林隐的博客
11-23 2304
设计模式之建造者（Builder）模式
（Builder）建造者模式
qq_32844875的博客
05-24 1282
建造者模式：将一个复杂对象与它表示分离，使得同样的构建过程可以创建不同的表示。使用了建造者模式，用户只需要指定需要建造的类型就可以得到他们，而具体建造的过程和细节就不需要知道了。就类似于麦当劳吃汉堡，具体味道怎么调，配料怎么配，店员都不需要知道。店员只需要按要求把材料组合都一起就可以了。当一个对象的构建过程非常复杂，且步骤单不会变化，就适合用建造者模式。设计思路：产品：Productpublic ...
深入理解C++设计模式：建造者模式详解
资源摘要信息:"c++-设计模式之‘建造者模式（Builder）’" 建造者模式（Builder Pattern）是一种创建型设计模式，它的主要作用是将一个复杂对象的构建与它的表示分离，从而使得同样的构建过程可以创建不同的表示。...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值