浅谈建造者模式
建造者模式的理解
建造者模式的理解建造者模式是⼀种对象构建设计模式，它提供了⼀种构建对象的最佳⽅式。
这种类型的设计模式属于创建型模式，它提供了⼀种创建对象的最佳⽅式。
在建造者模式中，我们将⼀个复杂对象的构建与其表示分离，使得同样的构建过程可以创建不同的表示。
建造者模式的⽬的是为了解决⼤型复杂对象的构建与其表示之间的耦合问题，它将构建对象的最佳⽅式交由专⻔的构建步骤来决定，⽽这个专⻔的构建步骤就是指挥者，指挥者负责组织各个部件的构建顺序，并依次调⽤每个部件的建造⽅法，从⽽完成复杂对象的构建。
建造者模式的适⽤场景包括：1.需要构建的对象具有复杂的内部结构，这些对象通常包含许多属性和⽅法；2.构建过程是独⽴于其他对象的，并且是可重⽤的；3.构建过程应当被封装起来，使得构建的步骤按照⼀定的顺序执⾏。
在实现建造者模式时，我们需要遵循以下原则：1.将⼀个复杂对象的构建与其表示分离，使得同样的构建过程可以创建不同的表示；2.创建型模式以某种⽅式修改请求的结构或表示。
由于结构问题产⽣的任何变化，都会改变这些类的⾏为。
因此，当需求发⽣改变时，我们可以修改请求的类⽽不是修改接收请求的类；3.创建型模式在客户端和抽象之间引⼊了⼀个指挥者类。
客户端通过指挥者类与抽象交互，从⽽实现了请求的结构或表示的修改。
由于指挥者类的引⼊，客户端不再直接与抽象交互，因此我们可以通过添加新的指挥者类来改变请求的发送⽅式。
建造者模式的优点包括：1.它提供了⼀种构建对象的最佳⽅式。
通过将构建过程抽象化，我们可以更加灵活地创建复杂的对象。
2.它使得构建过程与使⽤过程分离。
使⽤者只需要知道如何使⽤对象，⽽不需要关⼼对象的构建过程。
这使得代码更加简洁和易于维护。
3.它⽀持可复⽤的部件。
每个部件都是独⽴的，可以被复⽤在不同的构建过程中。
这提⾼了代码的复⽤性。
4.它使得对象构建更加灵活。
通过改变指挥者类的实现，我们可以改变对象的构建过程，从⽽实现不同的构建策略。
然⽽，建造者模式也有⼀些缺点：1.它增加了系统的复杂度。
设计模式中的建造者模式及应用
设计模式中的建造者模式及应用随着软件开发的不断推进，在设计模式中出现了越来越多的模式来协助我们更加有效地开发软件。
设计模式是一套可以解决特定问题的经典方法，它们提供了经过测试和验证的解决方案，可以在软件开发过程中减少错误和提高效率。
本文将介绍设计模式中的建造者模式及其应用。
一、什么是建造者模式？建造者模式是一种创建型设计模式，它允许我们通过分步骤构造复杂对象来创建不同类型和表示形式的对象。
该模式允许我们将对象的构造过程与其表示分离开来，从而可以独立地进行构建。
在建造者模式中，我们将一个大的构建步骤分解成若干个小的构建步骤，从而使得建造者可以按照需要组合和复用这些步骤。
这些步骤中的每一个都会返回自己的对象，这些对象最终会组合成一个完整的对象。
二、建造者模式的实现建造者模式的主要参与方包括产品、建造者和指挥者。
产品是最终被构建的对象，建造者是实际创建产品对象的类，而指挥者则是负责使用建造者对象构建产品对象。
下面是一个简单的建造者模式示例：1. 创建产品类public class Product {private String partA;private String partB;private String partC;public void setPartA(String partA) {this.partA = partA;}public void setPartB(String partB) {this.partB = partB;}public void setPartC(String partC) {this.partC = partC;}//其他方法}2. 创建建造者类public interface Builder {void buildPartA();void buildPartB();void buildPartC();Product getResult();}public class ConcreteBuilder implements Builder {private Product product;public ConcreteBuilder() {product = new Product();}@Overridepublic void buildPartA() {product.setPartA("PartA of the product"); }@Overridepublic void buildPartB() {product.setPartB("PartB of the product"); }@Overridepublic void buildPartC() {product.setPartC("PartC of the product");}public Product getResult() {return product;}}3. 创建指挥者类public class Director {private Builder builder;public Director(Builder builder) { this.builder = builder;}public void construct() {builder.buildPartA();builder.buildPartB();builder.buildPartC();}}4. 使用建造者模式创建产品public class Client {public static void main(String[] args) {Builder builder = new ConcreteBuilder(); Director director = new Director(builder); director.construct();Product product = builder.getResult();}}以上就是建造者模式的一个简单实现。
简说设计模式——建造者模式
简说设计模式——建造者模式⼀、什么是建造者模式 我们先说⼀个⽣活中的⼩例⼦，当我们在外⾯饭店吃饭时，⽐如点个⽔煮⾁⽚，这家店可能会辣⼀点、那家店可能会咸⼀点、对⾯那家可能放青菜、隔壁那家可能放菠菜，每家店做出来的都不⼀样，明明都是⽔煮⾁⽚却有不同的做法，如果都⼀样就不会说这家难吃那家好吃了。
那再看快餐店，⽐如KFC，我们点个⾄尊虾堡，所有⼈不管在哪个城市哪家店，做法、味道都是⼀样的，为什么呢，因为它⽤料、时间、温度等等都是严格规定的，我们只需要下订单就⾏了，这就是⼀个建造者模式。
建造者模式（Builder），将⼀个复杂的对象的构建与它的表⽰分离，使得同样的构建过程可以创建不同的表⽰。
UML结构图如下：其中，Director为指挥者/导演类，负责安排已有模块的顺序，然后告诉Builder开始建造；Builder是抽象建造者，规范产品的组建，⼀般由⼦类实现；ConcreteBuilder是具体建造者，实现抽象类定义的所有⽅法，并且返回⼀个组建好的对象；Product是产品类，通常实现了模板⽅法模式。
1. Director类导演类起到封装的作⽤，避免⾼层模块深⼊到建造者内部的实现类。
在建造者模式⽐较庞⼤时，导演类可以有多个。
1public class Director {23public void Construct(Builder builder) {4 builder.BuildPartA();5 builder.BuildPartB();6 }78 }2. Builder类抽象建造者类，确定产品由两个部件PartA和PartB组成，并声明⼀个得到产品建造后结果的⽅法getResult()。
public abstract class Builder {public abstract void BuildPartA(); //产品的A部件public abstract void BuildPartB(); //产品的B部件public abstract Product getResult(); //获取产品建造后结果}3. ConcreteBuilder类具体建造者类，有⼏个产品类就有⼏个具体的建造者，⽽且这多个产品类具有相同的接⼝或抽象类。
建造者模式在项目中的应用
建造者模式在项目中的应用一、引言建造者模式是一种创建型设计模式，它允许你分步骤地构造复杂对象。
该模式允许你使用相同的创建代码生成不同类型和形式的对象。
在本文中，将介绍建造者模式在项目中的应用，包括建造者模式的基本概念、优点和缺点，以及如何在项目中实现建造者模式。
二、建造者模式的基本概念1. 建造者：定义了产品的创建过程和最终结果，并提供了一个接口来返回最终创建结果。
2. 具体建造者：实现了建造者接口，并提供了具体的创建方法。
3. 产品：表示被构建的复杂对象。
4. 指挥者：指导具体建造者如何构建产品。
三、建造者模式的优点1. 将对象的构建过程与其表示分离，使得同样的构建过程可以创建不同的表示。
2. 可以更加精细地控制对象的构建过程，从而可以更好地满足需求。
3. 可以减少重复代码，提高代码复用性。
四、建造者模式的缺点1. 建造者模式需要额外定义多个类，增加了系统复杂度。
2. 对象必须有一个共同的接口，才能使用相同的构建过程。
五、建造者模式在项目中的应用建造者模式在实际项目中有很多应用场景，以下是其中几个典型的应用场景。
1. 安装程序安装程序通常需要进行一系列操作，例如检查系统配置、安装文件、创建快捷方式等。
这些操作可以使用建造者模式来实现。
具体建造者可以是不同类型的安装程序，例如 Windows 安装程序和 Linux 安装程序。
2. 网站生成器网站生成器通常需要根据用户需求生成不同类型和形式的网站。
这些网站可以使用建造者模式来实现。
具体建造者可以是不同类型的网站生成器，例如博客生成器和电商网站生成器。
3. 游戏角色创建在游戏开发中，角色创建通常需要进行一系列操作，例如选择职业、设置属性、选择技能等。
这些操作可以使用建造者模式来实现。
具体建造者可以是不同类型的角色创建器，例如战士创建器和法师创建器。
4. 订单处理订单处理通常需要根据用户需求生成不同类型和形式的订单。
这些订单可以使用建造者模式来实现。
建造者设计模式的特点
建造者设计模式的特点
建造者设计模式的特点主要包括以下几个方面：
1. 分离构建过程和表示：建造者模式将一个复杂对象的构建过程与它的表示分离开来，使得同样的构建过程可以创建不同的表示。
2. 隐藏产品内部细节：通过建造者模式，产品的具体实现细节被隐藏在具体建造者类中，客户端只需要知道如何调用建造者来构建产品即可，无需关心产品的具体构建过程。
3. 可以灵活选择构建过程中的具体实现：建造者模式允许客户端通过指定不同的具体建造者来选择不同的构建过程，从而创建不同的产品表现形式。
4. 避免重复创建对象：建造者模式中，通过指导者类来负责组织建造者类的调用顺序，使用同一个指导者对象可以重复执行相同的构建过程来创建不同的产品对象。
5. 客户端与产品的耦合度低：建造者模式通过引入指导者类，将客户端与产品的创建过程解耦，客户端只需通过指导者来创建产品，无需直接与具体的产品类交互。
综上所述，建造者设计模式主要特点是将复杂对象的构建过程与表示分离，隐藏
了产品内部细节，提供了灵活选择构建过程的方式，避免了重复创建对象，同时降低了客户端与产品的耦合度。
建造者模式的步骤和关键技术
建造者模式的步骤和关键技术建造者模式是一种创建型设计模式，它允许您将一个复杂的对象构建过程与其表示分离，从而使您能够单独生成和复用该对象表示。
在使用建造者模式时，您需要了解其步骤和关键技术。
下面将分别介绍这两个方面。
一、建造者模式的步骤1. 定义产品类：在建造者模式中，首先需要定义产品类。
产品类是您要创建的对象的基础。
2. 定义抽象建造者：抽象建造者是一个接口或抽象类，它定义了构建过程中要实现的方法。
这个接口将建造者从正在构建的对象表示中分离出来。
3. 实现具体建造者：具体建造者实现了抽象建造者接口中定义的方法，并创建了要构建的对象表示。
4. 定义指挥者：指挥者是一个接口或抽象类，它定义了执行构建过程的方法。
指挥者将具体建造者与产品类分离出来。
5. 实现具体指挥者：具体指挥者实现了指挥者接口中定义的方法，并使用具体建造者来构建要创建的对象表示。
6. 使用建造者模式构建对象：使用建造者模式创建一个对象表示需要实例化一个指挥者对象，并将一个具体建造者对象传递给它。
二、建造者模式的关键技术1. 建造者中的产品表示：在建造者模式中，产品表示是构建对象过程中要创建的对象。
这个对象可能是一个具有多个属性和方法的类，也可能是一个简单的数据结构。
2. 建造者接口或抽象类：一个建造者需要实现的方法由一个接口或抽象类定义。
这个接口或抽象类会告诉建造者应该做什么，如何做。
3. 具体构造者：具体构造者实现建造者接口或抽象类中定义的方法。
它们实际上构建了产品表示，并返回最终的结果。
4. 指挥者：指挥者是与具体构造者交互的对象。
它知道构建对象所需的步骤，并且使用它们来联系具体构造者。
它还可能使用基于某些条件的不同建造方案。
5. 建造者模式的优点：建造者模式允许您将复杂对象的构建步骤分离，并使您能够更好地控制它们。
它还可以提高对象表示的可重用性，并使更改该表示变得更加容易。
综上所述，建造者模式是一种创建型设计模式，它允许您将一个复杂的对象构建过程与其表示分离，从而使您能够单独生成和复用该对象表示。
C#设计模式之建造者设计模式(Builde)
产品（Product）角色：产品便是建造中的复杂对象。
指导者角色是于客户端打交道的角色。导演者角色将客户端创建产品的请求划分为对各个零件的建造请求，再将这些请求委派给具体建造者角色。具体建造者角色是做具造者（Builder）模式
建造者模式可以将一个产品的内部表象与产品的生成过程分割开来，从而可以使一个建造过程生成具有不同的内部表象的产品对象。
对象性质的建造
有些情况下，一个对象会有一些重要的性质，在它们没有恰当的值之前，对象不能作为一个完整的产品使用。比如，一个电子邮件有发件人地址、收件人地址、主题、内容、附录等部分，而在最起码的收件人地址未被赋值之前，这个电子邮件不能发出。
具体建造者（Concrete Builder）角色：担任这个角色的是于应用程序紧密相关的类，它们在应用程序调用下创建产品实例。这个角色主要完成的任务包括：
实现Builder角色提供的接口，一步一步完成创建产品实例的过程。
在建造过程完成后，提供产品的实例。
指导者（Director）角色：担任这个角色的类调用具体建造者角色以创建产品对象。导演者并没有产品类的具体知识，真正拥有产品类的具体知识的是具体建造者对象。
命名的考虑
之所以使用"建造者"而没有用"生成器"就是因为用零件生产产品，"建造"更为合适，"创建"或"生成"不太恰当。
二、Builder模式的结构：
建造者（Builder）角色：给出一个抽象接口，以规范产品对象的各个组成成分的建造。一般而言，此接口独立于应用程序的商业逻辑。模式中直接创建产品对象的是具体建造者（ConcreteBuilder）角色。具体建造者类必须实现这个接口所要求的方法：一个是建造方法，另一个是结果返还方法。
设计模式学习之建造者模式
跟JBPM学设计模式之建造者模式模式简介建造者模式，将一个复杂对象的构建与它的表示分离，使得同样的构建过程可以创建不同的表示。
一个产品常常会有不同的组成成分作为零部件，这些零件可能是对象，也可能不是对象，他们通常由叫做产品的内部表象。
不同的产品可以有不同的内部表象，也就是不同的零部件。
使用建造者模式可以使客户端不需要知道所生成的产品对象有哪些零部件，每个产品的相应零部件有什么不同，是怎么建造出来的，以及是怎样组成产品的。
建造者模式的简图如下图1. 建造者模式结构图在这个示意图中，最终产品是由两部分组成的，所以相应的建造方法也有两个。
这个模式涉及到一下四个角色。
抽象建造者角色：给出一个接口，规范产品对象的各个组成部分的建造。
一般而言此接口独立于应用程序的商业逻辑。
模式中直接创建产品的具体建造者，必须实现这个接口所要求的两种方法，一种是建造方法，比如图中BuildPart1（）和BuildPart2；另外一种是结果返回方法，即图中的GetProduct（）。
一般来说产品所包含的零部件数目与建造方法的数目相符。
具体建造者角色：担任这个角色的是与应用程序紧密相关的一些类，他们在应用程序调用下创建产品的实例。
其需要完成任务包括：实现抽象建造者builder所声明的接口，给出一步一步创建产品实例的操作。
建造过程完成后，提供产品的实例。
导演者角色：其调用具体的建造者角色以创建产品对象。
应当指出的是，导演者角色并没有产品类的具体知识，真正具有与产品类具体知识的是具体的建造者角色。
产品角色：产品就是模式中要建造的复杂对象。
导演者角色是与客户端打交道的角色。
导演者角色将客户端创建产品的请求划分为对各个零件的建造请求，再将这些请求委派给具体建造者角色。
具体建造者角色是做具体建造工作的，但是却不为客户端所知。
一般而言，每有一个产品类，就有一个相应的具体建造者类。
这些产品应当有一定数目的零件，而每有一个两件就相应的在所有建造者橘色里有一个建造方法。
建造者模式的优势与典型应用案例
建造者模式的优势与典型应用案例在软件开发领域中，设计模式是一种通用的解决方案，用于解决常见的问题。
其中，建造者模式是一种创建型设计模式，用于将一个复杂对象的构建过程与其表示相分离，以便相同的构建过程可以创建不同的表示。
本文将介绍建造者模式的优势和典型应用案例。
一、建造者模式的优势1.1 提供灵活性和可扩展性建造者模式可以将复杂对象的构建过程分解为多个简单的步骤，每个步骤由一个具体的建造者实现。
通过定义不同的建造者实现，可以构建出不同的表示。
这有助于提供灵活性和可扩展性，使得系统能够适应不同的需求变化。
1.2 隐藏复杂对象的创建细节使用建造者模式可以将复杂对象的创建细节隐藏起来，使得客户端不需要知道对象的具体创建过程。
客户端只需要知道如何使用建造者对象，而不需要关心对象的内部实现细节。
这样可以降低系统的耦合度，提高代码的可维护性和可读性。
1.3 代码复用和可读性建造者模式可以将相同的构建过程用于创建不同的表示，从而实现代码的复用。
通过定义不同的建造者实现，可以复用已有的构建过程，减少重复代码的编写。
同时，由于将构建过程拆分为多个步骤，使得代码更加清晰可读，易于理解和维护。
1.4 构建过程逐步完善建造者模式支持逐步完善构建过程，即可以在创建对象的过程中逐步填充对象的属性和方法。
这使得构建过程更加灵活，可以根据实际需求来进行调整和改进。
同时，逐步完善构建过程也有助于提高代码的可测试性，方便进行单元测试和集成测试。
二、建造者模式的典型应用案例2.1 汽车制造业在汽车制造业中，建造者模式可以用于构建不同类型的汽车。
汽车的构建过程可以分解为多个步骤，如组装发动机、安装座椅、喷涂车身等。
通过定义不同的建造者，可以实现不同类型的汽车的构建过程。
例如，可以定义一个轿车建造者和一个SUV建造者，分别用于构建轿车和SUV。
2.2 游戏角色创建在游戏开发中，建造者模式可以用于创建不同类型的游戏角色。
游戏角色的构建过程可以分解为多个步骤，如设置角色属性、选择武器装备、设定技能等。
建造者模式的作用和意义
建造者模式的作用和意义建造者模式，这可真是个挺有意思的东西呢。
你有没有搭过积木呀？一块一块小小的积木，在你手里能变成各种各样的东西，可能是一座漂亮的小房子，也可能是一辆酷炫的小汽车。
这就有点像建造者模式的作用呢。
建造者模式就像是一个超级有耐心、超级有创意的积木搭建大师。
它能把那些看起来零零散散的小零件，按照一定的规则和顺序，组合成一个完整的、很棒的大东西。
比如说，你要盖一栋大楼。
这可不是一件简单的事儿啊。
要是没有个好的方法，那可就乱套了。
建造者模式就出现啦，它就像一个智慧的指挥家。
混凝土、钢筋、砖块，这些就好比是建造大楼的原材料，也就是程序里的各个组件。
如果没有建造者模式，就好像一群工人各自为政，拿着材料乱堆一气，最后盖出来的可能就是个歪歪扭扭、随时会倒的怪物建筑。
可是有了建造者模式呢，就不一样啦。
它有条不紊地指挥着，先把地基打好，用钢筋混凝土筑牢根基，就像给大楼穿上了一双结实的鞋子，让它稳稳地站在地上。
然后一层一层地往上砌砖，每一层都按照设计的高度和宽度来，这就像是给大楼穿上了一件合身的衣服，规规矩矩的。
从意义上来说，建造者模式给我们带来了好多方便。
它让整个构建的过程变得清晰起来。
就像我们画画的时候，要是没有一个好的步骤，颜料到处乱涂，最后画出来的东西肯定乱七八糟。
建造者模式就是那个告诉我们先画轮廓，再上颜色，一块一块地把画完善起来的好帮手。
在软件开发中也是这样啊。
它可以让不同的开发人员专注于不同的部分。
就好比盖房子的时候，有的工人专门负责砌墙，有的工人专门负责安装水电。
大家都按照建造者模式这个大计划来，各司其职，效率不就提高了嘛。
再说说定制化这方面。
你去买衣服，有的衣服是那种批量生产的，大家都一样，没什么个性。
但是如果有个设计师按照你的身材、你的喜好，一件一件地给你做衣服呢？这就很特别了。
建造者模式就可以做到这样的定制化。
你想要一个软件有这个功能，不要那个功能，就像你想要衣服上有这个口袋，不要那个装饰一样。
什么情况下才应该使用建造者模式
什么情况下才应该使用建造者模式一、什么是建造者模式建造者模式是一种创建型设计模式，它允许你创建复杂对象的过程与其表示分离，使得同样的构建过程可以创建不同的表示形式，通常用于创建对象构造器参数数量较多的对象。
二、建造者模式的特点1、将一个复杂对象的构建与表示分离，使得同样的构建过程可以创建不同的表示形式。
2、隐藏系统组件的复杂性，使用户仅需要指定需要的部件构造方式即可得到所需对象。
3、封装复杂构建过程，使其可以独立变化，而不会影响其他部分。
三、什么情况下应该使用建造者模式1、需要创建复杂的对象，其构造器参数数量较多，且参数之间存在一定的依赖关系。
例如汽车制造业，在制造汽车时需要大量的构造参数，如发动机、车轮、座椅、空调等，这些构造参数之间存在着一定的依赖关系，使用建造者模式可以将不同的构造参数组合成不同的汽车对象。
2、需要创建可复用的对象，可以通过调用不同的构造器，创建不同的表示形式。
例如使用建造者模式可以设计一个模板化的房屋模型，根据不同的需求，调用不同的构造器，创建不同的风格、不同大小的住宅。
3、需要隐藏构造细节，使得用户只需关注如何创建对象，无需了解对象的构建细节。
例如在游戏制作中，需要创建一系列特定的游戏角色，使用建造者模式可以隐藏构建细节，使得用户只需指定角色类型，即可创建所需角色。
四、建造者模式的优缺点优点：1、通过建造者模式，可以将对象的构建与表示分离，使得构建过程可以灵活地改变，而不会对用户造成影响。
2、使用建造者模式可以封装构建细节，使得对象的构建过程更加简单灵活，且易于扩展。
3、可以创建不同形式的对象表示方式，以满足不同的用户需求。
缺点：1、建造者模式需要创建许多不同的类，增加系统复杂性。
2、建造者模式的创建过程较为复杂，需要多个类之间的协作，需要耗费较多的时间和精力。
五、建造者模式的实例在实际应用中，建造者模式被广泛使用，例如在Java的StringBuilder类中，就是使用了建造者模式，其允许你将多个字符串连接在一起，构建成一个新的字符串。
java 建造者模式链式调用条件处理
一、概述建造者模式是一种创建型设计模式，通过使用链式调用的方式来构建复杂的对象。
在Java中，建造者模式可以帮助我们简化对象的构建过程，并且提供了一种灵活的方式来处理不同的构建条件。
本文将介绍Java建造者模式的基本原理以及如何使用链式调用来处理条件。
二、建造者模式的基本原理建造者模式通过将一个复杂对象的构建过程分解成多个简单的步骤来实现。
它包括以下几个主要角色：1. 产品（Product）：需要被构建的复杂对象。
2. 抽象建造者（Builder）：定义了构建产品的接口，包括构建产品的各个步骤。
3. 具体建造者（ConcreteBuilder）：实现了抽象建造者接口，负责具体的产品构建过程。
4. 指挥者（Director）：负责组装具体建造者来构建最终的产品。
三、Java建造者模式的实现在Java中，建造者模式可以通过链式调用的方式来实现。
链式调用是指在调用对象方法时，每次调用都返回一个新的对象，从而可以在一个表达式中连续调用多个方法。
这种方式可以使代码更加清晰、简洁，并且提供了一种灵活的方式来处理条件。
四、链式调用的条件处理在使用建造者模式的过程中，有时候会根据不同的条件来设置对象的属性或调用不同的方法。
链式调用可以很好地处理这种情况。
下面是一些处理条件的示例代码：1. 使用if-else语句处理条件```javapublic class ProductBuilder {private Product product;public ProductBuilder() {product = new Product();}public ProductBuilder setName(String name) {product.setName(name);return this;}public ProductBuilder setPrice(int price) {product.setPrice(price);return this;}public ProductBuilder setCategory(String category) { if (category.equals("book")) {product.setDiscount(0.1);} else {product.setDiscount(0.0);}product.setCategory(category);return this;}public Product build() {return product;}}```2. 使用策略模式处理条件```javapublic interface DiscountStrategy {double applyDiscount(double price);}public class BookDiscountStrategy implementsDiscountStrategy {Overridepublic double applyDiscount(double price) { return price * 0.9;}}public class OtherDiscountStrategy implements DiscountStrategy {Overridepublic double applyDiscount(double price) { return price;}}public class ProductBuilder {private Product product;public ProductBuilder() {product = new Product();}public ProductBuilder setName(String name) {product.setName(name);return this;}public ProductBuilder setPrice(int price) {product.setPrice(price);return this;}public ProductBuilder setCategory(String category) {DiscountStrategy discountStrategy;if (category.equals("book")) {discountStrategy = new BookDiscountStrategy();} else {discountStrategy = new OtherDiscountStrategy();}product.setPrice(discountStrategy.applyDiscount(product.getPri ce()));product.setCategory(category);return this;}public Product build() {return product;}}```3. 使用Optional类处理可选属性```javapublic class Product {private String name;private int price;private String category;private Optional<Double> discount;public Product(String name, int price, String category) { = name;this.price = price;this.category = category;this.discount = Optional.empty();}public Product setDiscount(double discount) {this.discount = Optional.of(discount);return this;}}public class ProductBuilder {private Product product;public ProductBuilder(String name, int price, String category) {product = new Product(name, price, category);}public Product build() {return product;}}```五、总结建造者模式是一种非常有用的设计模式，它可以帮助我们简化对象的构建过程，并且提供了一种灵活的方式来处理条件。
设计模式之建造者模式
在我们生活中就有许多的模式是建造者模式,比如建房子
房子本身有很多个组成部分，各组件息息相关缺一不可，否则
房倒屋塌。而其构造过程也是相当复杂的,这里只将其简化拆分成地 基、墙体、屋顶三部分，首先来看建筑物类。
为了模拟建筑物通用类中各组件的建造顺序，我们在以List来模 拟三个组件的堆叠，之后是它们对应的三个建造方法，最后于看起 来是不难，但怎样从这个类直接构造出一个房子呢？怎样去设置这 些字符串的组件属性呢？此时客户端一头雾水，还是找个专业施工 方吧，先定义个施工方接口。
既然是施工方的接口，那一定有实现类了，先来写一个高端别墅施 工队。
我们可以看到，工程总监在宏观上操控着整个施工队的建造流程， 在第13行的指导方法中以自下而上的顺序建造房屋，他并不在乎是 哪个施工队来造房子，但施工步骤是由他来控制的。是时候满足客 户的住房刚需了，组建团队，运行程序。
我们还是得找一个有资质的工程总监去控制整个建造工序流程。
UML图
Java设计模式之（三）——建造者模式
Java设计模式之（三）——建造者模式1、什么是建造者模式Separate the construction of a complex object from its representation so that the same construction process can create different representations.将⼀个复杂对象的构建与它的表⽰分离，使得同样的构建过程可以创建不同的表⽰。
说⼈话：将构造复杂对象的过程和组成对象的部件解耦。
就像攒电脑⼀样，不管什么品牌的配件，只要兼容就可以装上；同样，⼀样的配件，可以有好多组装的⽅式。
更直接点就是同⼀个类，通过内部不同属性状态构造不同的对象。
2、建造者模式定义在建造者模式中，有 4 个定义：①、Product(产品类) :我们具体需要⽣成的类对象②、Builder(抽象建造者类)：为我们需要⽣成的类对象，构建不同的模块属性，即：公开构建产品类的属性，隐藏产品类的其他功能。
③、ConcreteBuilder(具体建造者类)：实现抽象类定义的所有⽅法，并返回⼀个组建好的对象。
④、Director(导演类)：确定构建我们的类对象具体有哪些模块属性，在实际应⽤中可以不需要这个⾓⾊，直接通过client处理。
3、实例⽐如我们去买车，⼀般同⼀辆车会有多个版本，根据配置不⼀样，分为经典版、舒适版、豪华版等，⽐如经典版是⼿动挡⼿动座椅，舒适版是⾃动挡全景天窗等。
public class Car {// 车名称private String name;// ⾃动挡private String automaticCatch;// ⼿动挡private String manualTransmission;// 全景天窗private String panoramicSunroof;// ⾃动座椅private String automaticSeat;// ⼿动座椅private String manualSeat;// 倒车影像private String reversingImage;//省略get/set⽅法}3.1 普通实现public class GeneralTest {public Car getCarInstance(String carName){Car car = new Car();if("经典版".equals(carName)){car.setName("经典版");car.setManualTransmission("⼿动挡");}else if("舒适版".equals(carName)){car.setName("舒适版");car.setAutomaticCatch("⾃动挡");car.setManualSeat("⼿动座椅");}else if("豪华版".equals(carName)){car.setName("豪华版");car.setAutomaticCatch("⾃动挡");car.setAutomaticSeat("⾃动座椅");car.setReversingImage("倒车影像");car.setPanoramicSunroof("全景天窗");}else{throw new IllegalArgumentException("carName is error: carName="+carName);}return car;}}注意，并不是说⾼版本汽车⼀定具有低版本所有配置，⽐如舒适版配置是⼿动座椅，豪华版是⾃动座椅，⽽且不同版本之间配置有交叉。
设计模式系列建造者模式
设计模式系列建造者模式想自己的开发路子走得更远更久，想成为更牛的码农，那设计模式的理解和掌握是必须的。
老田，能详细说说你的段位2吗？很多人也都听说过建造者设计模式，但总是对这个设计模式理解得不够透彻，今天我们就来聊聊建造者设计模式。
另外也说说建造者设计模式和工厂模式的区别。
定义其实建造者设计模式的定义，很多事看不懂的，也是记不住的，但我们还是得先来看看是如何定义的。
将一个复杂对象的构建与其表示分离，使得同样的构建过程可以创建不同的表示另外在维基百科解释是：是不是觉得非常的不好理解？下面我们就用生活中的案例，反过来理解建造者设计模式的定义会更好。
案例1借用并改造下 Effective Java 中给出的例子：每种食品包装上都会有一个营养成分表，每份的含量、每罐的含量、每份卡路里、脂肪、碳水化合物、钠等，还可能会有其他N 种可选数据，大多数产品的某几个成分都有值，该如何定义营养成分这个类呢？重叠构造器因为有多个参数，有必填、有选填，最先想到的就是定义多个有参构造器：第一个构造器只有必传参数，第二个构造器在第一个基础上加一个可选参数，第三个加两个，以此类推，直到最后一个包含所有参数，这种写法称为重叠构造器，有点像叠罗汉。
还有一种常见写法是只写一个构造函数，包含所有参数。
代码如下：public class Nutrition {private int servingSize;// requiredprivate int servings;// requiredprivate int calories;// optionalprivate int fat;// optionalprivate int sodium;// optionalprivate int carbohydrate;// optionalpublic Nutrition(final int servingSize, final int servings) {this(servingSize, servings, 0, 0, 0, 0);}public Nutrition(final int servingSize, final int servings, final i nt calories) {this(servingSize, servings, calories, 0, 0, 0);}public Nutrition(final int servingSize, final int servings, final i nt calories, final int fat) {this(servingSize, servings, calories, fat, 0, 0);}public Nutrition(final int servingSize, final int servings, final i nt calories, final int fat, final int sodium) {this(servingSize, servings, calories, fat, sodium, 0);}public Nutrition(final int servingSize, final int servings, final i nt calories, final int fat, final int sodium, final int carbohydrate) { this.servingSize = servingSize;this.servings = servings;this.calories = calories;this.fat = fat;this.sodium = sodium;this.carbohydrate = carbohydrate;}// getter}这种写法还可以有效解决参数校验，只要在构造器中加入参数校验就可以了。
建造者模式——结合案例，通俗易懂
建造者模式——结合案例，通俗易懂⼀个设计模式解决⼀类问题，最近学习了⼀下建造者模式，看了很多博客，讲的模棱两可，所以决定写⼀下我觉得⽐较好理解的简介参考⾃知乎⼀、介绍1、啥是建造者模式是将⼀个复杂的对象的构建与它的表⽰分离，使得同样的构建过程可以创建不同的表⽰看不懂对吧！其实我也看不懂，不管它，通过案例和代码加深理解2、使⽤场景⼀个设计模式解决⼀类问题，那么建造者模式解决了什么问题呢？——对象的构建过于复杂的问题当⼀个类的构造函数参数过多（超过四个），并且有的参数可有可⽆，或者很多产品有默认值。
产品类⾮常复杂或者产品类因为调⽤顺序不同⽽产⽣不同作⽤3、优点复杂产品的创建步骤分解在不同的⽅法中，这些⽅法可以调⽤顺序不同，结果不同，创建结果很清晰4、缺点如果产品的内部变化复杂，可能会导致需要定义很多具体建造者来实现这种变化。
⼆、案例理论总是难以理解的，现在通过案例分析问题，⼀步步了解使⽤建造者模式的好处【案例】好好看⼀下这个案例KFC套餐假如⽬前KFC⾥⾯有很多个套餐在套餐⾥⾯有必点，也有选点，然后每个单品⼜有⼤⼩之分必点：汉堡（hamburger），薯条（chips）选点：鸡腿（chicken），可乐（cola），披萨（pizza）【⽤Java代码模拟场景】我们如何构成这么多套餐实例呢？我们不使⽤建造者模式也能构建代码，但是建造者模式会让代码看上去更装逼，代码到后期更结构化更容易维护和拓展⾸先构建这个实体类KFCpublic class KFC {//套餐必点private String hamburger;private String chips;//套餐选点private String chicken;private String cola;private String pizza;}我们的想法是不是折叠构造函数来创建实例，下⾯来尝试⼀下public class KFC{//省略了上⾯的属性.....//必点套餐Apublic KFC(String hamburger,String chips){this(hamburger,chips,null,null,null);}A//套餐Bpublic KFC(String hamburger,String chips,String chicken){this(hamburger,chips,chicken,null,null);}//套餐Cpublic KFC(String hamburger,String chips,String chicken,String cola){this(hamburger,chips,chicken,cola,null);}//......还有好多种组合⽅式，你会发现使⽤折叠构造函数的⽅法⼗分复杂//全选public KFC(String hamburger,String chips,String chicken,String cola,String pizza){this.hamburger = hamburger;this.chips = chips;this.chicken = chicken;this.cola = cola;this.pizza = pizza;}}我们会发现使⽤折叠构造函数的⽅式很复杂，很恶⼼，代码看都不想看那么有⼈会想，我可以使⽤set⽅法来创建，我只要⼀个必点构造就好了，那继续模拟咯public class KFC{//.....省略了属性//必点public KFC(String hamburger,String chips){this.hamburger = hamburger;this.chips = chips;}//set⽅法public void setChicken(String chicken) {this.chicken = chicken;}public void setCola(String cola) {this.cola = cola;}public void setPizza(String pizza) {this.pizza = pizza;}//实例化对象，你会发现这种⽅式就友好很多public static void main(String[] args) {KFC kfc = new KFC("⼤汉堡","⼤薯条");//加⼩份可乐kfc.setCola("⼩可乐");//加个鸡腿kfc.setChicken("⼤鸡腿");System.out.println(kfc);}}你会发现使⽤set⽅式就友好了很多这个虽然友好了很多，但是也有点⼩⽑病，就是你set太随意了，我可能这个套餐⾥⾯没有这个单品，⽽使⽤set的⼈却不知道，造成错误的套餐出现！。
构建者（建造者）模式
构建者（建造者）模式引⼦在软件系统中，有时候⾯临着“⼀个复杂对象”的创建⼯作，期通常由各个部分的⼦对象⽤⼀定的算法构成；由于需求的变化，这个复杂的对象各个部分经常⾯临着剧烈变化，但是将它们组合在⼀起的算法却是相对稳定。
概念构建者模式是⼀个独特的设计模式，有助于使⽤简单的对象构造复杂的对象平使⽤算法。
类图例⼦分析例如⼿机，它是由屏幕，主板，处理器等等组成的，但是组成⼿机的这些各个部分是可变的。
不同的型号的⼿机所采⽤的这些组件都是不⼀样的；如处理器有联发科、⾼通、英伟达等等。
同理主板与⼿机屏⽬也是这样。
复杂对象在这例⼦中复杂的对象指的是⼿机这东西，它是由多个⼦对象组成的。
变化部分变化的部分指的是组成⼿机这对象的各个⼦对象，它们是可变的。
如处理器有联发科、⾼通、英伟达等等。
算法部分假设⼿机都是构造是这样：主板->处理器-> 屏幕 ->完成主板上安装处理器然后在装上屏幕⼀个⼿机就这样构造完成了。
实现代码class Mobile:def __init__(self):self.self.__cpu = Noneself.__screen = Noneself.__master = Nonedef set_cpu(self, value):self.__cpu = valuedef set_screen(self, value):self.__screen = valuedef set_master(self, value):self.__master = valuedef __repr__(self):def __repr__(self):return f' <Mobile(master={self.__master}screen={self.__screen}cpu={self.__cpu})>'class AbsMobileBuild(abc.ABC):def __init__(self):self._mobileself._mobile = Mobile() # CPU部分 @abc.abstractmethod def set_cpu(self): pass # 主板部分 @abc.abstractmethoddef set_master(self): pass# 屏幕部分 @abc.abstractmethoddef set_screen(self): passdef get_result(self) -> Mobile:.return self._mobileclass MobileDirector:def __init__(self, build: AbsMobileBuild):self.build = builddef __call__(self) -> Mobile:self.build.set_master()self.build.set_cpu()self.build.set_master()self.build.set_cpu()self.build.set_screen()return self.build.get_result()class XiaoMiMobileBuild(AbsMobileBuild):def set_cpu(self):self._mobile.set_cpu("⼩⽶CUP")def set_master(self):self._mobile.set_master("⼩⽶主板")def set_screen(self):self._mobile.set_screen("⼩⽶屏幕")class HuaWeiMiMobileBuild(AbsMobileBuild):def set_cpu(self):self._mobile.set_cpu("华为CUP")def set_master(self):self._mobile.set_master("华为主板")def set_screen(self):self._mobile.set_screen("华为屏幕")if __name__ == "__main__":buildbuild = XiaoMiMobileBuild()director = MobileDirector(build)director = MobileDirector(build) mobile = director()print(mobile)build1build1 = HuaWeiMiMobileBuild() director1 = MobileDirector(build1) mobile1 = director1()print(mobile1)。
描述建造者设计模式特点
描述建造者设计模式特点
建造者设计模式是一种单例模式的变种,它通过创建一个实例来代表整个应用程序。
这个实例可以被在整个应用程序中共享,并且可以被修改而不会影响其他实例。
以下是建造者设计模式的特点:
1. 单例模式:建造者模式中,有一个全局唯一的单例对象,其他实例都是从这个单例对象中创建的。
2. 可重用性:由于建造者对象的可重用性,整个应用程序都可以使用相同的单例对象,从而节省了大量的代码。
3. 安全性:由于建造者对象是全局唯一的,因此应用程序中的所有建造者对象都具有相同的安全性。
4. 懒加载:在需要时加载建造者对象,而不是在首次运行时加载。
可以避免由于频繁创建和销毁对象而导致的性能问题。
5. 共享性:建造者对象可以被在整个应用程序中共享,从而使整个应用程序中的代码更加紧凑和易于维护。
6. 灵活性:由于建造者对象是可重用的,因此可以根据需要进行更改和扩展,而不会影响整个应用程序。
7. 应用场景:建造者模式适用于需要共享单例对象的场景,例如:数据库连接池、缓存、消息队列等。
拓展:建造者模式还可以应用于其他领域,例如:游戏开发、Web应用程序、移动应用程序等。
在这些领域中,可以使用建造者模式来创建具有相同功能的组件,从而使得整个应用程序更加简单和易于维护。
设计模式 建造者模式
FAFU
返回目录
2 建造者模式的意图和适用性
以下情况可以使用建造者模式： 1. 需要生成的产品对象有复杂的内部结构。 2. 创建复杂对象的算法稳定，或建造者模式 可以强迫生成一定的顺序。 3. 当构造过程允许被构造的对象有不同的表 示时。
FAFU
返回目录
3 建造者模式的结构和参与者
建造者模式结构图
创建型设计模式 -之建造者模式
创建型模式有：
1 2 3 4 5 工厂模式 抽象工厂模式 建造者模式 单件模式 原型模式
FAFU
返回目录
建造者（Builder）模式
一、建造者模式的由来 二、建造者模式的意图及适用性 三、建造者模式的结构 四、应用举例 五、效果分析
FAFU
返பைடு நூலகம்目录
1 建造者模式的由来
FAFU
返回目录
4 应用举例
设计游戏场景中的房屋 假设房屋由五个部分组成：地板、墙壁、窗 户、门和天花板。 构建一个房屋的步骤是一定的，而具体的组 件（门、窗等）是易变的。 采用建造者模式分离易变组件和稳定的构建 过程。
FAFU
返回目录
3 建造者模式的结构和参与者
建造者模式结构图
过程不变 部件易变
返回目录
FAFU
FAFU
返回目录
4 应用举例
public abstract class House//定义一个房屋抽象类 {} public abstract class Builder//这一部分是易变的 { public abstract void BuildFloor();//地板 public abstract void BuildDoor();//门 public abstract void BuildWindows();//窗 户 public abstract void BuildWall();//墙壁 public abstract void BuildHouseCeiling()// 天花板 } public abstract House GetHouse();
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
浅谈建造者模式
“设计模式是一套被反复使用的、多数人知晓的、经过分类编目的、代码设计经验的总结。
使用设计模式是为了重用代码、让代码更容易被他人理解、保证代码可靠性。
毫无疑问，设计模式于己于他人于系统都是多赢的，设计模式使代码编制真正工程化，设计模式是软件工程的基石，如同大厦的一块块砖石一样。
项目中合理地运用设计模式可以完美地解决很多问题，每种模式在现实中都有相应的原理来与之对应，每种模式都描述了一个在我们周围不断重复发生的问题，以及该问题的核心解决方案，这也是设计模式能被广泛应用的原因。
”在设计模式这门课程的学习中，我们了解到了有23种设计模式，每种模式都有他们的特色，而在学习设计模式的过程中，最令我印象深刻的就是建造者模式。
建造者模式是一种较为复杂的创建型模式，他将客户端与包含多个组成部分的复杂对象的创建过程分离，客户端无需知道复杂对象的内部组成部分与装配方式，只需知道所需的建造者类型即可。
建造者模式关注一步一步地创建一个复杂对象，不同的具体建造者定义了不同的创建过程，且具体建造者相互独立，增加新的建造着非常方便，无需修改已有代码，系统具有较好的扩展性。
这让我联想到了游戏里面的角色设计，如果每个新角色的设计都要重新编写代码的话就会耗费相当大的功夫，但是如果用建造者模式的思想来设计的话就会轻松很多，增加新的建造者非常方便，无需修改已有代码，可以提高代码的复用率，减少重复“造轮子”的时间。
结合本学期所学到的设计模式知识以及以前学的专业知识，我做了一个LOL（英雄联盟）角色设计的小项目。
在这个项目中，我使用了五个类来进行编写（代码详情见src文件夹）。
图1 LOL角色设计结构图
（1）Builder(抽象建造者)：构建者接口，定义构建各部件的方法。
（2）RoleBuilder (具体建造者)：实现Builder的接口以构造和装配该产品的各个部件，定义并明确它所创建的表示，并提供一个检索产品的接口。
（3）Role(产品角色)：表示被构造的角色。
RoleBuilder创建该产品的内部表示并定义它的装配过程，包含定义组成部件的类，包括将这些部件装配成最终产品的接口。
（4）Director(指挥者)：构造一个使用Builder接口的对象。
（5）Client(成品类):将所设计的角色在控制台进行输出。
在编写的过程中，我发现建造者模式与抽象工厂模式有点相似，但是建造者模式返回的是一个完整的复杂产品，而抽象工厂模式则是返回一系列相关的产品。
在抽象工厂模式中，客户端通过选择具体工厂来生成所需对象，而在建造者模式中，客户端通过指定具体建造者类型并指导Director类如何去生成对象，然后将结果返回。
我觉得，在建造者模式中，最重要的一点就是它引进了Director（）类，它一方面隔离了客户与创建过程，另一方面也控制了产品的创建过程，指挥者针对抽象建造者编程，客户端只需要知道具体建造者的类型，就可以通过指挥者类调用建造者的相关方法，这让我联想到了生活中的案例，例如客户想要自己组装一台电脑，销售人员只需要确定客户的需求，就可以以让组装人员为客户组装电脑，客户无
需了解装配的具体过程。
所以设计模式中的很多模式都是来源于生活，然后又作用于生活，不禁令我赞叹于前人的智慧。
这也让我有所启发，学习设计模式，不能只拘泥于形式，重要的是其中的思想，要在运用时能够信手拈来。
而要做到这点，就要求我们要学会观察生活，尤其是我们学习计算机的学生，更加要观察生活，因为我们编程就是为了让世界变得更美好，让人们生活得更加方便。
在此次的小项目中，我就联想到了游戏里面人物的设计，游戏需要更新，角色需要增加，但是不可能每增加一个角色就改所有的代码，所以我想到了使用建造者模式来解决这一问题。
在我的小项目里面，如果要修改角色信息，只需要更改RoleBuilder()类即可，如果想要增加新角色，可以增加一个新的具体角色建造类，原有代码无需修改，这完全符合设计模式的开闭原则。
凡事有利也有弊，建造者模式也一样，通过这次的项目开发，我了解到建造者模式的优点：（1）在建造者模式中，客户端不必知道产品内部组成的细节，将产品本身与产品的创建进行解耦，使得相同的创建过程可以创建不同的产品对象。
在我编写的LOL角色创建项目里，我就利用了这一点来进行角色的创建，只需要修改或者增加少量的代码，就可以达到目的。
（2）每一个具体建造者都是独立的，与其他的具体建造者无关，因此可以很方便的替换具体建造者或增加具体建造者用户使用不同的具体建造者即可得到不同的产品对象，由于指挥者类针对抽象建造者编程，增加新的具体建造者无需修改原有类库的代码，系统扩展方便，符合开闭原则。
在代码编写中，代码复用率是尤为重要的，我此次的项目也极力地做到大多数代码能够重复使用。
（3）用户可以更加精细的控制产品的创建过程，将复杂的产品的创建步骤分解在不同的方法中，使得创建过程更加清晰，也更方便使用程序来控制创建过程。
我此次的项目分为5个类，实现了LOL角色设计的分解，也使得代码条理清晰，创建也更加方便。
但是建造者模式也有缺点，建造者模式的缺点：
（1）建造者模式所创建的产品一般具有较多的共同点，其组成部分相似，如果产品之间的差异性较大，例如很多组成部分不相同，则不适合使用建造者模式，因此使用范围收到一定的限制。
在此次LOL 角色设计的项目中，我就体会到了这一点，我所设计的角色，都是大同小异，不能够有特殊的东西，不然就无法实现，这也是建造者模式的一个局限性之所在。
（2）如果产品的内部变化复杂，可能会需要定义很多具体建造者类来实现这种变化，导致系统变得和庞大，增加了系统的理解难度和运行成本。
在此次代码的编写中，为了实现不同的角色实例，必须要建不同的具体类，这样长此以往，有多少个角色就要增加多少个类，这会大大增加产品的内存占用率，这对于用户来说是不愿意看到的
经过这次LOL角色设计的小项目，我更加深刻地体会到了设计模式的重要性，它在我们的编程过程中，有着举足轻重的作用，尤其是对建造者模式有了更加深入的体会。
我意识到，建造者模式的核心在于如何一步一步地构建一个包含多个组成部件的完整对象，使用相同的构建过程构建不同的产品。
在编程中要多使用设计模式，使我们的代码具有更高的可读性和可复用性。
参考文献
[1] 刘伟，胡志刚，郭克华.设计模式.北京：清华大学出版社，2011
[2]刘继华.漫谈设计模式——从面向对象开始.北京：清华大学出版社，2012
[3]莫永腾.深入浅出设计模式(C#/Java).北京：清华大学出版社，2006
[4]陈臣，王斌.研磨设计模式.北京：清华大学出版社，2010
[5]秦小波.设计模式之禅.北京：机械工业出版社，2010。