建造者模式
建造者模式
造 者 模式
YOUTH GRADUATION
JAPANESE PURE AND FRESH
JAPANESE PURE AND FRESH
PART 00 目录
1 建造者模式的由来 2 建造者模式的意图及适用性 3 建造者模式的结构 4 应用举例 5 效果分析
PART 01 建造者模式的由来
在软件系统中，有时候面临着“一个复杂 对象”的创建工作
骤构建算法”的需求变动。
望大家批评指正
}
PART 04 应用举例
//定义抽象的Builder public abstract class Builder {
//添加主板 public abstract void addMainBoard(); //添加CPU public abstract void addCPU(); //添加内存 public abstract void addMemory(); //获取组装好的产品 public abstract Computer GetComputer(); }
PART 04 应用举例
//具体建造者，建造一台普通性能计算机 public class OrdinaryComputer : Builder {
private Computer Ocomputer = new Computer(); public override void AddMainBoard()//具体装主板的方法 {OComputer.add(“中档主板”);} public override void AddCPU() //具体装CPU的方法 {OComputer.add(“P4 2.0GHz”);} public override void AddMemory() //具体装内存的方法 {OComputer.add(“512MB内存”);} public override void GetComputer() //具体获得产品的方法 {return OComputer;} }
建造者模式的理解
建造者模式的理解建造者模式是⼀种对象构建设计模式，它提供了⼀种构建对象的最佳⽅式。
这种类型的设计模式属于创建型模式，它提供了⼀种创建对象的最佳⽅式。
在建造者模式中，我们将⼀个复杂对象的构建与其表示分离，使得同样的构建过程可以创建不同的表示。
建造者模式的⽬的是为了解决⼤型复杂对象的构建与其表示之间的耦合问题，它将构建对象的最佳⽅式交由专⻔的构建步骤来决定，⽽这个专⻔的构建步骤就是指挥者，指挥者负责组织各个部件的构建顺序，并依次调⽤每个部件的建造⽅法，从⽽完成复杂对象的构建。
建造者模式的适⽤场景包括：1.需要构建的对象具有复杂的内部结构，这些对象通常包含许多属性和⽅法；2.构建过程是独⽴于其他对象的，并且是可重⽤的；3.构建过程应当被封装起来，使得构建的步骤按照⼀定的顺序执⾏。
在实现建造者模式时，我们需要遵循以下原则：1.将⼀个复杂对象的构建与其表示分离，使得同样的构建过程可以创建不同的表示；2.创建型模式以某种⽅式修改请求的结构或表示。
由于结构问题产⽣的任何变化，都会改变这些类的⾏为。
因此，当需求发⽣改变时，我们可以修改请求的类⽽不是修改接收请求的类；3.创建型模式在客户端和抽象之间引⼊了⼀个指挥者类。
客户端通过指挥者类与抽象交互，从⽽实现了请求的结构或表示的修改。
由于指挥者类的引⼊，客户端不再直接与抽象交互，因此我们可以通过添加新的指挥者类来改变请求的发送⽅式。
建造者模式的优点包括：1.它提供了⼀种构建对象的最佳⽅式。
通过将构建过程抽象化，我们可以更加灵活地创建复杂的对象。
2.它使得构建过程与使⽤过程分离。
使⽤者只需要知道如何使⽤对象，⽽不需要关⼼对象的构建过程。
这使得代码更加简洁和易于维护。
3.它⽀持可复⽤的部件。
每个部件都是独⽴的，可以被复⽤在不同的构建过程中。
这提⾼了代码的复⽤性。
4.它使得对象构建更加灵活。
通过改变指挥者类的实现，我们可以改变对象的构建过程，从⽽实现不同的构建策略。
然⽽，建造者模式也有⼀些缺点：1.它增加了系统的复杂度。
java建造者模式举例
java建造者模式举例建造者模式是一种创建型设计模式，用于创建一个复杂对象，其中包含多个部分，而且这些部分的创建过程是相对独立的。
建造者模式将对象的构建过程与其表示分离，从而允许你创建不同的表示。
下面是一个简单的Java建造者模式的示例，假设我们要创建一个包含多个属性的`Computer`对象，属性包括CPU、内存、硬盘等：首先，定义`Computer`类以及与之对应的`ComputerBuilder`类：```java// Computer类public class Computer {private String cpu;private String memory;private String hardDisk;private String graphicsCard;private String monitor;public Computer(String cpu, String memory, String hardDisk, String graphicsCard, String monitor) {this.cpu = cpu;this.memory = memory;this.hardDisk = hardDisk;this.graphicsCard = graphicsCard;this.monitor = monitor;}// 添加getter方法}// ComputerBuilder类public class ComputerBuilder {private String cpu;private String memory;private String hardDisk;private String graphicsCard;private String monitor;public ComputerBuilder setCpu(String cpu) {this.cpu = cpu;return this;}public ComputerBuilder setMemory(String memory) {this.memory = memory;return this;}public ComputerBuilder setHardDisk(String hardDisk) {this.hardDisk = hardDisk;return this;}public ComputerBuilder setGraphicsCard(String graphicsCard) {this.graphicsCard = graphicsCard;return this;}public ComputerBuilder setMonitor(String monitor) {this.monitor = monitor;return this;}public Computer build() {return new Computer(cpu, memory, hardDisk, graphicsCard, monitor);}}```现在，您可以使用`ComputerBuilder`来创建`Computer`对象，允许逐步设置不同属性：```javapublic class Main {public static void main(String[] args) {Computer computer = new ComputerBuilder().setCpu("Intel i7").setMemory("16GB").setHardDisk("512GB SSD").setGraphicsCard("NVIDIA GeForce RTX 3080").setMonitor("27-inch 4K").build();System.out.println("Computer details:");System.out.println("CPU: " + computer.getCpu());System.out.println("Memory: " + computer.getMemory());System.out.println("Hard Disk: " + computer.getHardDisk());System.out.println("Graphics Card: " + computer.getGraphicsCard());System.out.println("Monitor: " + computer.getMonitor());}}```使用建造者模式，您可以根据需要设置不同的属性，并且不需要构建一个具有多个构造函数参数的复杂构造函数。
建造者（Builder）模式的若干使用场景
建造者（Builder）模式的若⼲使⽤场景1.场景⼀如果我们需要将⼀个复杂对象的构建与它的表⽰分离，使得同样的构建过程可以创建不同的表⽰的意图时，我们可以使⽤ Builder模式，⼜叫⽣成器模式。
如果我们⽤了Builder模式，那么⽤户就只需要指定需要建造的类型就可以得到它们，⽽具体建造的过程和细节就不需要知道了。
⽐如现在我们有⼀个这样的使⽤场景，需要在屏幕上画⼩⼈，⼈要有头⼿脚，要画不同的⼈，胖的⼩⼈，瘦的⼩⼈，矮的⼩⼈。
按照通常的写法，会有很多的样板代码，画⼈的头，画⼈脚⼿，如果⼀不⼩⼼，⾮常容易缺胳膊少腿。
下⾯我们演⽰Builder模式的实现：public class Person {//限于篇幅get和set⽅法此处省略Head head;Body body;Arm leftArm;Arm rightArm;Leg leftLeg;Leg rightLeg;public void drawHead(int size){...}public void drawBody(int size){...}public void drawLeftArm(int size){...}public void drawRightArm(int size){...}public void drawLeftLeg(int size){...}public void drawRightLeg(int size){...}}abstract class BuilderPerson {protected Person person = new Person();public abstract void buildHead();public abstract void buildBody();public abstract void buildLeftArm();public abstract void buildRightArm();public abstract void buildLeftLeg();public abstract void buildRightLeg();}public class BuilderThinPerson extends BuilderPerson{@Overridepublic void buildHead() {person.drawHead(10);}@Overridepublic void buildBody() {person.drawBody(10); //画胖⼩⼈只需将这边的数值修改，// 再⽣成⼀个类即可}@Overridepublic void buildLeftArm() {person.drawLeftArm(5);}@Overridepublic void buildRightArm() {person.drawRightArm(5);}@Overridepublic void buildLeftLeg() {person.drawLeftLeg(7);}@Overridepublic void buildRightLeg() {person.drawRightLeg(7);}}我们还缺Builder模式中⼀个⾮常重要的类，指挥者(Director)，⽤它来控制建造过程，也⽤来隔离⽤户与建造过程的关联。
面向对象23种设计模式
面向对象23种设计模式面向对象23种设计模式在面向对象的编程中，设计模式是一种解决问题的通用方案。
设计模式可以帮助开发人员在开发过程中减少代码的冗余和复杂性，并提高代码的可维护性和可重用性。
本文将介绍23种面向对象的设计模式。
1. 工厂方法模式工厂方法模式是一种创建型设计模式，它定义了一个用于创建对象的接口，但是让子类决定实例化哪个类。
在工厂方法模式中，客户端不需要知道具体的创建逻辑，只需要知道工厂类中定义的接口即可。
2. 抽象工厂模式抽象工厂模式是一种创建型设计模式，它提供了一个接口，用于创建相关或依赖对象的家族，而不需要指定它们的具体类。
在抽象工厂模式中，客户端不需要知道具体的创建逻辑，只需要知道工厂类中定义的接口即可。
3. 单例模式单例模式是一种创建型设计模式，它保证一个类只有一个实例，并提供一个访问该实例的全局点。
4. 原型模式原型模式是一种创建型设计模式，它允许复制或克隆一个现有的对象，而不必知道其具体实现。
5. 建造者模式建造者模式是一种创建型设计模式，它允许逐步创建复杂的对象，而不必知道其内部实现细节。
6. 适配器模式适配器模式是一种结构型设计模式，它将一个或多个不兼容的类或接口转换为客户端所需的接口。
7. 桥接模式桥接模式是一种结构型设计模式，它将抽象部分与其实现部分分离开来，以便独立地进行修改。
8. 组合模式组合模式是一种结构型设计模式，它将一组对象作为单个对象处理，以便客户端可以以相同的方式处理单个对象和组合对象。
9. 装饰器模式装饰器模式是一种结构型设计模式，它允许向现有对象添加额外的功能，同时不改变其现有的结构。
10. 外观模式外观模式是一种结构型设计模式，它为一组复杂的子系统提供了一个统一的接口，以便于客户端使用。
11. 享元模式享元模式是一种结构型设计模式，它利用共享技术来最小化内存使用，以及提高应用程序的性能。
12. 代理模式代理模式是一种结构型设计模式，它提供了一个代理对象，使得客户端可以通过代理对象间接地访问实际对象。
系统架构设计师23种设计模式记忆口诀
系统架构设计师23种设计模式记忆口诀设计模式分为三种类型：创建型设计模式（4种：工厂模式（工厂模式、抽象工厂模式）、单例模式、原型模式、建造者模式）主要用户创建对象；创建型：创建模式创对象。
工厂模式要抽象；单例只有一个类；拷贝原型创对象；建造复杂的对象。
解释：创建模式主要用于创建对象。
工厂模式根据业务需要分为简单工厂模式、工厂方法模式和抽象工厂模式；原型模式用于创建重复的对象，通过拷贝这些原型创建新的对象；建造者模式使用多个简单的对象一步一步构建成一个复杂的对象。
------------------------------------------------------------------------------- 结构型设计模式（8种：代理模式、外观模式、装饰器模式、享元模式、组合模式、适配器模式、桥接模式、过滤器）主要关注类和对象的组合；结构型：结构组合类对象。
代理外观装饰器；享元组合适配器；桥接不能过滤器。
代理对象访问者；外观一致的接口；装饰动态添职责；享元共享搞对象。
组合对象像棵树；适配接口能兼容；桥接抽象与实现；不同标准来过滤。
解释：结构型设计模式主要关注类和对象的组合。
主要有代理模式、外观模式、装饰器模式、享元模式、组合模式、适配器模式、桥接模式不能继承，过滤器模式。
代理模式为其他对象提供一种代理以控制对这个对象的访问；外观模式通过为多个复杂的子系统提供一个一致的接口，而使这些子系统更加容易被访问的模式，这是典型的”迪米特原则“；装饰器模式动态地给一个对象添加一些额外的职责；享元模式运用共享技术来有效地支持大量细粒度对象的复用；组合模式将对象组合成树形结构以表示"部分-整体"的层次结构；适配器模式将一个类的接口转换成客户希望的另外一个接口，使得原本由于接口不兼容而不能一起工作的那些类可以一起工作；桥接模式将抽象部分与实现部分分离，使它们都可以独立的变化；过滤器模式允许开发人员使用不同的标准来过滤一组对象，通过逻辑运算以解耦的方式把它们连接起来行为型设计模式（11种：模板模式、策略模式、迭代器模式、中介模式、备忘录模式、解释器模式、观察者模式、访问者模式、状态模式、责任链模式、命令模式）主要关注对象间通信的问题。
建造者模式（Builder）
建造者模式（Builder）3.1 建造者模式（Builder）例⼦：根据计算机组件组装不同的计算机。
⽤这个例⼦来理解⼀下创建者模式：⾸先这个模式做的事情是这样的，现在有⼀堆计算机零件，⽐如说⼀块硬盘它可以放在笔记本电脑上也可以放在台式机上，那么建造者模式就是把不同电脑的构建和表⽰分离，提供⼀个计算机产品类，⾥⾯包含了计算机的零件，之后提供⼀张“图纸”这张图纸就是⼀个抽象建造者接⼝，这个接⼝提供了创建的⽅法以及返回复杂对象的⽅法，具体的建造者会实现这个接⼝，⽤这张“图纸”来创造不同类型的计算机。
具体⾓⾊：具体产品⾓⾊：Computer抽象建造者：ComputerBuilder具体建造者：DeskTopComputer、LapTopComputer指挥者：ComputerWaiter注意点：抽象建造者⾥要去new⼀个具体产品。
protected Computer computer = new Computer();抽象建造者⾥需要定义⼀个返回复杂产品的⽅法public Computer getComputer(){return computer;}具体建造者继承⾃抽象建造者，实现⾥⾯的所有建造⽅法！public class DeskTopBuilder extends ComputerBuilder指挥者类是真正⼲活的类public class ComputerWaiter {private ComputerBuilder cb;public void setCb(ComputerBuilder cb){this.cb=cb;}public Computer construct(){cb.buildCPU();cb.buildHardDisk();cb.buildMainFrame();cb.buildMemory();return cb.getComputer();}}这个类需要拥有⼀个抽象建造者的对象，利⽤这个对象调⽤其建造的⽅法来完整⼀个具体的产品并调⽤其⽅法把这个产品返回！总结：具体产品类提供了⼀个产品需要的零件。
面向对象设计的23个设计模式详解
面向对象设计的23个设计模式详解面向对象设计是一种广泛应用于软件开发的思想，其核心在于将数据和操作封装在一起形成对象，并通过各种方式进行交互和组合，从而实现复杂的功能。
在这一过程中，设计模式起到了非常重要的作用，可以有效地提高代码的可读性、可维护性和可扩展性。
本文将对23种常见的设计模式进行详解。
一、创建型模式1.简单工厂模式简单工厂模式属于创建型模式，其目的是提供一个工厂类，使得创建对象的过程更加简单。
在这种模式中，使用者只需要提供所需对象的参数，而无需关心对象的具体实现细节。
简单工厂模式适合于对象创建过程较为简单的情况。
2.工厂方法模式工厂方法模式是简单工厂模式的进一步扩展，其核心在于将工厂类进行接口抽象化，使得不同的工厂类可以创建不同的对象实例。
工厂方法模式适合于对象创建过程较为复杂的情况。
它可以为工厂类添加新的产品类型，而不会影响原有的代码。
3.抽象工厂模式抽象工厂模式是工厂方法模式的进一步扩展，其目的是提供一个可以创建一系列相关或者独立的对象的接口。
在抽象工厂模式中，使用者只需要关心所需对象组合的类型，而无需关注对象的具体实现过程。
4.建造者模式建造者模式也是一种创建型模式，其目的在于将复杂对象分解为多个简单的部分，并将其组装起来形成复杂对象实例。
在建造者模式中，使用者只需要关注所需对象以及它们的组合方式，而无需关心对象的具体实现过程。
5.原型模式原型模式是一种基于克隆的创建型模式，其核心在于通过复制现有的对象实例来创建新的对象。
在原型模式中，对象实例的创建过程与对象所包含的状态密切相关。
原型模式适合于创建复杂对象实例，且这些对象实例之间是相对独立的情况。
二、结构型模式6.适配器模式适配器模式是一种结构型模式，其目的在于将一个类的接口转换为另一个类所能使用的接口。
在适配器模式中，使用者可以通过不同的适配器实现对象之间的互相调用。
7.桥接模式桥接模式是一种结构型模式，其目的在于将抽象部分与实现部分相互分离，从而使得两者可以独立变化。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
建造者模式
定义：将一个复杂对象的构建与它的表示分离，使得同样的构建过程可以创建不同的表示。
类型：创建类模式
类图：
四个要素
∙产品类：一般是一个较为复杂的对象，也就是说创建对象的过程比较复杂，一般会有比较多的代码量。
在本类图中，产品类是一个具体的类，而非抽象类。
实际编程中，产品类可以是由一个抽象类与它的不同实现组成，也可以是由多个抽象类与他们的实现组成。
∙抽象建造者：引入抽象建造者的目的，是为了将建造的具体过程交与它的子类来实现。
这样更容易扩展。
一般至少会有两个抽象方法，一个用来建造产品，一个是用来返回产品。
∙建造者：实现抽象类的所有未实现的方法，具体来说一般是两项任务：组建产品；返回组建好的产品。
∙导演类：负责调用适当的建造者来组建产品，导演类一般不与产品类发生依赖关系，与导演类直接交互的是建造者类。
一般来说，导演类被用来封装程序中易变的部分。
代码实现
建造者模式的优点
首先，建造者模式的封装性很好。
使用建造者模式可以有效的封装变化，在使用建造者模式的场景中，一般产品类和建造者类是比较稳定的，因此，将主要的业务逻辑封装在导演类中对整体而言可以取得比较好的稳定性。
其次，建造者模式很容易进行扩展。
如果有新的需求，通过实现一个新的建造者类就可以完成，基本上不用修改之前已经测试通过的代码，因此也就不会对原有功能引入风险。
建造者模式与工厂模式的区别
我们可以看到，建造者模式与工厂模式是极为相似的，总体上，建造者模式仅仅只比工厂模式多了一个“导演类”的角色。
在建造者模式的类图中，假如把这个导演类看做是最终调用的客户端，那么图中剩余的部分就可以看作是一个简单的工厂模式了。
与工厂模式相比，建造者模式一般用来创建更为复杂的对象，因为对象的创建过程更为复杂，因此将对象的创建过程独立出来组成一个新的类——导演类。
也就是说，工厂模式是将对象的全部创建过程封装在工厂类中，由工厂类向客户端提供最终的产品；而建造者模式中，建造者类一般只提供产品类中各个组件的建造，而将具体建造过程交付给导演类。
由导演类负责将各个组件按照特定的规则组建为产品，然后将组建好的产品交付给客户端。
总结
建造者模式与工厂模式类似，他们都是建造者模式，适用的场景也很相似。
一般来说，如果产品的建造很复杂，那么请用工厂模式；如果产品的建造更复杂，那么请用建造者模式。
本文作者：zhengzhb。