👈️上一篇:抽象工厂模式 | 下一篇:原型模式👉️
目录
- 建造者模式
- 概览
- 定义
- 英文原话
- 直译
- 如何理解呢？
- 建造者模式将对象的建造过程给抽象出来了
- 类比选购汽车
- 4个角色
- UML类图
- 1. 抽象建造者（Builder）角色
- 2. 具体建造者（Concrete Builder）角色
- 3. 产品（Product）角色
- 4. 导演者（Director）角色
- 代码示例
- 1. 抽象建造者Builder.java
- 2. 具体建造者ConcreteBuilder
- 3. 导演者Director.java
- 4. 产品类Product.java
- 5. 测试类：DemoTest.java
- 优点
- 使用场景
- 建造者模式示解析：构造笔记本电脑对象
- 源码
- 类图
- 1. 抽象建造者：ComputerBuilder.java
- 2. 具体建造者
- 2.1 具体的某型号电脑建造者： T410Builder.java（建造T410）
- 2.2 具体的某型号电脑建造者： X201Builder.java（建造X201）
- 3. 抽象产品类：Computer.java
- 4. 具体产品类
- 4.1 具体的某型号电脑产品类：T410.java
- 4.2 具体的某型号电脑产品类：X201.java
- 5. 导演者、指挥官、客户端类：ComputerDirector.java
- 6. 测试类：DemoTest.java
建造者模式
建造者模式（Builder Pattern）也叫做生成器模式。
=>>>>>本文源码<<<<<==
概览
-
定义
- 如何理解呢？
- 类比选购汽车
- 如何理解呢？
-
4个角色
- 代码示例
-
优点
-
使用场景
-
建造者模式示解析：构造笔记本电脑对象
定义
英文原话
Separate the construction of a complex object from its representation so that the same construction process can create different representations.
直译
将复杂对象的构造与其表示分离，以便相同的构造过程可以创建不同的表示。
如何理解呢？
建造者模式和单例模式、工厂模式一样，也属于创建型设计模式。
创建型模式抽象了实例化的过程，即对象创建的过程。
建造者模式将对象的建造过程给抽象出来了
建造模式的产品类有各种各样、复杂、可配置项，建造者就是抽象了所有可供客户调用的为产品对象进行配置的方法，最后提供一个返回产品实例的方法。
这样客户端（使用该类的就是该类客户端，就是导演者、指挥官角色）可以按需进行配置，调用相应的配置方法即可，最后所有所需要的配置都配置好，执行build()方法进行构造产品对象即可，这样客户就得到了一个自己所需的对象实例。
类比选购汽车
打个比方就是买车（汽车就是一个产品类），
但是裸车是可以选配各种配件的，
比如高级音响，高档皮质座椅、高端轮毂、车漆等等，这些配置你是可选的，
你选配（选配的过程就是调用建造者提供的各个可选的配置方法）好了
告诉（“告诉”这一动作就是执行build()方法）
4s店（就是建造者，他会为你提车），
最终你（你就是客户端，就是导演者、指挥者角色，告诉了建造者你的需求，并让建造者为你提供一个所需的产品实例）
获得了精心选配的爱车（该车就是客户按需获得的产品类实例，也就是你获得了一个你需要的产品对象）就会有这些配置。
4个角色
UML类图
1. 抽象建造者（Builder）角色
接口、或者抽象类，意在制定规范、统一标准（所有的具体建造者都按照我说的来做），具体的实现由实现类或子类（具体建造者）进行实现。
该角色规定了产品建造的各个可选配置（可按需配置），并提供一个构造对象的build()抽象方法。
2. 具体建造者（Concrete Builder）角色
对抽象构建者的实现。
持有一个产品对象属性，且该类提供多个方法可供外部选择调用，对该产品对象进行配置，然后对外提供一个build()方法，返回根据客户建造的产品对象。
这里和之前工厂模式区分开，简化理解，产品角色不分抽象产品角色和具体产品角色，只有一个产品类。复杂的场景再对产品类进行抽象。
其实本质上就是通过建造者将对象的建造过程给抽象了：建造者类内持有一个原始产品对象，客户（在这里的客户就是导演者、指挥者角色）可以按需配置，最终生产出所需产品对象。
3. 产品（Product）角色
该角色是建造中的复杂对象，有多种多样的、丰富的可配属性。
4. 导演者（Director）角色
即客户端，根据自己需要对要建造的对象进行配置，最后执行build()方法，获得产品实例。
代码示例
=>>>>>代码示例<<<<<==
1. 抽象建造者Builder.java
package com.polaris.designpattern.list1.creational.pattern4.builder.proto;
public abstract class Builder {
// 设置产品的不同部分，以获得不同的产品
public abstract void setPart1();
public abstract void setPart2();
public abstract void setPart3();
// ......其他部件
// 建造产品
public abstract Product buildProduct();
}
2. 具体建造者ConcreteBuilder
package com.polaris.designpattern.list1.creational.pattern4.builder.proto;
public class ConcreteBuilder extends Builder {
private Product product = new Product();
@Override
public void setPart1() {
// 为product配置部件1
System.out.println("set part 1 for the product.");
}
@Override
public void setPart2() {
// 为product配置部件2
System.out.println("set part 2 for the product.");
}
@Override
public void setPart3() {
// 为product配置部件3
System.out.println("set part 3 for the product.");
}
// ......配置其他部件
// 建造一个产品
@Override
public Product buildProduct() {
return product;
}
}
3. 导演者Director.java
package com.polaris.designpattern.list1.creational.pattern4.builder.proto;
public class Director {
private Builder builder = new ConcreteBuilder();
public Product build(){
builder.setPart1();
builder.setPart2();
builder.setPart3();
// ......其他部件
return builder.buildProduct();
}
}
4. 产品类Product.java
package com.polaris.designpattern.list1.creational.pattern4.builder.proto;
public class Product {
// 产品类的业务处理方法
// ...
}
5. 测试类：DemoTest.java
package com.polaris.designpattern.list1.creational.pattern4.builder.proto;
public class DemoTest {
public static void main(String[] args) {
Director director = new Director();
Product product = director.build();
}
}
/* Output:
set part 1 for the product.
set part 2 for the product.
set part 3 for the product.
*///:~
优点
建造者模式的优点有以下几个方面。
- 封装性，使用建造者模式可以使客户端不必知道产品内部组成的细节。
- 建造者独立，容易扩展.
- 便于控制细节风险，由于具体的建造者是独立的，因此可以对建造过程逐步细化，而不对其他的模块产生任何影响。
使用场景
使用建造者模式的典型场景如下。
- 相同的方法，不同的执行顺序，产生不同的结果时，可以采用建造者模式。
- 多个部件或零件，都可以装配到一个对象中，但是产生的运行结果又不相同时，则可以使用该模式。
- 产品类非常复杂，或者产品类中的方法调用顺序不同产生了不同的效果，这个时候使用建造者模式。
- 在对象创建过程中会使用到系统的一些其他对象，这些对象在产品对象的创建过程中不易得到时，也可以采用建造者模式封装该对象的创建过程。该种场景只能是一个补偿方法，因为一个对象不容易获得，而在设计阶段没有发现，要通过创建者模式柔化创建过程，本身已经违反设计的最初目标。
- [注]：建造者模式关注的是零件类型和装配工艺顺序，这是与工厂方法模式最大的不同之处，虽然同为创建类模式，但是重点不同。
建造者模式示解析：构造笔记本电脑对象
源码
=>>>>>代码示例<<<<<==
类图
- 产品类可以对产品进行抽象（抽象类），抽象（定义）共有属性，具体产品特有属性在具体产品中在声明
- 具体产品继承抽象产品类，某具体产品独有的属性在具体产品类中声明
- 抽象建设者不仅提供设置产品实例公共属性的方法，还要声明个别产品自己独有的属性设置方法
- 具体建设者可以不止一个（用于构建不同的产品），但都要实现抽象构建者的接口，每个具体产品对应一个具体建设者。
1. 抽象建造者：ComputerBuilder.java
注意有的笔记本有独立显卡，有的笔记本没有独立显卡，因此配置独显是个别产品独有的
但是，抽象建造者也需要声明（规定）该属性的配置方法。
package com.polaris.designpattern.list1.creational.pattern4.builder;
public interface ComputerBuilder {
void buildCpu();//配置CPU
void buildRam();//配置内存
void buildHardDisk();//配置硬盘
void buildGraphicCard();//***|配置显卡|****
void buildMonitor();//配置显示器
void buildOs();//配置操作系统
Computer build();//得到配置好的计算机
}
2. 具体建造者
2.1 具体的某型号电脑建造者： T410Builder.java（建造T410）
T410有配备独显
package com.polaris.designpattern.list1.creational.pattern4.builder;
public class T410Builder implements ComputerBuilder {
private T410 computer = new T410();
@Override
public void buildCpu() {
computer.setCpu("i5-450");
}
@Override
public void buildRam() {
computer.setRam("4G 1333MHz");
}
@Override
public void buildHardDisk() {
computer.setHardDisk("500GB 7200转");
}
@Override
public void buildGraphicCard() {
computer.setGraphicCard("Nvidia NVS 3100M");//***配置独显***
}
@Override
public void buildMonitor() {
computer.setMonitor("14英寸 1280*800");
}
@Override
public void buildOs() {
computer.setOs("Windows 7 旗舰版");
}
@Override
public T410 build() {
return computer;
}
}
2.2 具体的某型号电脑建造者： X201Builder.java（建造X201）
X201没有独显
package com.polaris.designpattern.list1.creational.pattern4.builder;
public class X201Builder implements ComputerBuilder {
private X201 computer = new X201();
@Override
public void buildCpu() {
computer.setCpu("i3-350");
}
@Override
public void buildRam() {
computer.setRam("2G 1333MHz");
}
@Override
public void buildHardDisk() {
computer.setHardDisk("250GB 5400转");
}
@Override
public void buildGraphicCard() {
// 无显卡
// X201没有独立显卡，没有独显属性，不用操作
}
@Override
public void buildMonitor() {
computer.setMonitor("12英寸 1280*800");
}
@Override
public void buildOs() {
computer.setOs("Windows 7 Home版");
}
@Override
public X201 build() {
return computer;
}
}
3. 抽象产品类：Computer.java
对电脑配置进行抽象
package com.polaris.designpattern.list1.creational.pattern4.builder;
import lombok.Data;
@Data
public abstract class Computer {
private String type;
private String cpu;
private String ram;
private String hardDisk;
private String monitor;
private String os;
}
4. 具体产品类
4.1 具体的某型号电脑产品类：T410.java
该机型配备独显属性
继承了抽象产品类的所有属性，并声明了特有的属性-显卡
package com.polaris.designpattern.list1.creational.pattern4.builder;
import lombok.Getter;
import lombok.Setter;
public class T410 extends Computer {
@Getter
@Setter
private String graphicCard; //***有独显***
public T410() {
this.setType("ThinkPad T410i");
}
@Override
public String toString() {
return "型号：\t" + this.getType() + "\nCPU：\t" + this.getCpu()
+ "\n内存：\t" + this.getRam() + "\n硬盘：\t" + this.getHardDisk()
+ "\n显卡：\t" + this.getGraphicCard() + "\n显示器：\t" + this.getMonitor()
+ "\n操作系统：\t" + this.getOs();
}
}
4.2 具体的某型号电脑产品类：X201.java
该机型没有配备独显属性
继承了抽象产品类的所有属性，并且没有自己特有的属性
package com.polaris.designpattern.list1.creational.pattern4.builder;
public class X201 extends Computer {
public X201() {
this.setType("ThinkPad X201i");
}
@Override
public String toString() {
return "型号：\t" + this.getType() + "\nCPU：\t" + this.getCpu()
+ "\n内存：\t" + this.getRam() + "\n硬盘：\t" + this.getHardDisk()
+ "\n显示器：\t" + this.getMonitor()
+ "\n操作系统：\t" + this.getOs();
}
}
5. 导演者、指挥官、客户端类：ComputerDirector.java
之所以提供多个名字，意在方便理解。其实就是建造者的客户端，用来告诉建造者如何构造对象，并进行构建。
package com.polaris.designpattern.list1.creational.pattern4.builder;
public class ComputerDirector {
ComputerBuilder builder;
public T410 constructT410() {
builder = new T410Builder();
builder.buildCpu();
builder.buildRam();
builder.buildHardDisk();
builder.buildGraphicCard();
builder.buildMonitor();
builder.buildOs();
return (T410) builder.build();
}
public X201 constructX210() {
builder = new X201Builder();
builder.buildCpu();
builder.buildRam();
builder.buildHardDisk();
builder.buildMonitor();
builder.buildOs();
return (X201) builder.build();
}
}
6. 测试类：DemoTest.java
package com.polaris.designpattern.list1.creational.pattern4.builder;
public class DemoTest {
public static void main(String[] args) {
ComputerDirector director = new ComputerDirector();
Computer t410 = director.constructT410();
System.out.println(t410);
System.out.println("--------------------------");
Computer x210 = director.constructX210();
System.out.println(x210);
}
}
/* Output:
型号： ThinkPad T410i
CPU： i5-450
内存： 4G 1333MHz
硬盘： 500GB 7200转
显卡： Nvidia NVS 3100M
显示器： 14英寸 1280*800
操作系统： Windows 7 旗舰版
--------------------------
型号： ThinkPad X201i
CPU： i3-350
内存： 2G 1333MHz
硬盘： 250GB 5400转
显示器： 12英寸 1280*800
操作系统： Windows 7 Home版
*///~
👈️上一篇:抽象工厂模式 | 下一篇:原型模式👉️
![[桌面端应用开发] 从零搭建基于Caliburn的图书馆管理系统（C#合集）](https://img-blog.csdnimg.cn/direct/ea5f33c958744931bc4bff299a36a9a7.png)
