What:
建造者模式是将一个复杂的对象的构建与表示分离，使得同样的构建过程可以创建不同的表示。建造者模式隐藏了复杂对象的创建过程，它把复杂对象的创建过程加以抽象，通过子类继承或者重载的方式，动态的创建具有复合属性的对象。
Why:
优点：
1.遵循开闭原则。
2.对象的建造和表示分离，实现了解耦。
3.隐藏了对象的建造细节，用户只需关心产品的表示，而不需要了解是如何创建产品的。
缺点：
1.如果构造者多，会有很多的建造类，难以维护。
2.产品的组成部分必须相同，这限制了其使用范围。
Where:
1.隔离复杂对象的创建和使用，相同的方法，不同执行顺序，产生不同事件结果
2.需要生成的产品对象的属性相互依赖，需要指定其生成顺序。
How:
在学习使用建造者模式之前，我们需要了解几个概念。
Product：具体的产品。
Builder：抽象的建造方法。
ConcreteBuilder：具体的建造者。
Director(指挥官)：调用具体构造者创建的产品对象，负责将客户端传来指令交给具体的建造者。
建造者模式UML
主要有以下两种方式设计建造者模式：
一、通过Product，Builder，ConcreteBuilder，Director设计的建造者模式
ComputerElement类：具体的对象
/**
* 计算机元件
*/
public class ComputerElement {
private String CPU;
private String mainboard;
private String memory;
private String SSD;
private String power;
private String computerCase;
public ComputerElement() {
}
public ComputerElement(String CPU, String mainboard, String memory, String SSD, String power, String computerCase) {
this.CPU = CPU;
this.mainboard = mainboard;
this.memory = memory;
this.SSD = SSD;
this.power = power;
this.computerCase = computerCase;
}
@Override
public String toString() {
final StringBuilder sb = new StringBuilder("电脑组装元件如下：\n");
sb.append("CPU：")
.append(CPU).append('\n');
sb.append("主板:")
.append(mainboard).append('\n');
sb.append("内存：")
.append(memory).append('\n');
sb.append("SSD：")
.append(SSD).append('\n');
sb.append("电源：")
.append(power).append('\n');
sb.append("机箱：")
.append(computerCase).append('\n');
sb.append("正在组装中...").append('\n');
sb.append("组装完成！").append('\n');
return sb.toString();
}
// 省略get、set方法
}
ComputerBuilder：抽象的建造方法
/**
* 组装电脑抽象建造者
*/
public interface ComputerBuilder {
ComputerBuilder buildCPU(String CPU);
ComputerBuilder buildMainboard(String mainboard);
ComputerBuilder buildMemory(String memory);
ComputerBuilder buildSSD(String SSD);
ComputerBuilder buildPower(String power);
ComputerBuilder buildComputerCase(String computerCase);
ComputerElement build();
}
ComputerActualBuilder：具体的建造者
/**
* 组装电脑具体建造者
*/
public class ComputerActualBuilder implements ComputerBuilder {
ComputerElement computerElement = new ComputerElement();
@Override
public ComputerBuilder buildCPU(String CPU) {
computerElement.setCPU(CPU);
return this;
}
@Override
public ComputerBuilder buildMainboard(String mainboard) {
computerElement.setMainboard(mainboard);
return this;
}
@Override
public ComputerBuilder buildMemory(String memory) {
computerElement.setMemory(memory);
return this;
}
@Override
public ComputerBuilder buildSSD(String SSD) {
computerElement.setSSD(SSD);
return this;
}
@Override
public ComputerBuilder buildPower(String power) {
computerElement.setPower(power);
return this;
}
@Override
public ComputerBuilder buildComputerCase(String computerCase) {
computerElement.setComputerCase(computerCase);
return this;
}
@Override
public ComputerElement build() {
return computerElement;
}
}
ComputerDirector：指挥官
/**
* 指挥官
*/
public class ComputerDirector {
private ComputerBuilder computerBuilder = new ComputerActualBuilder();
public ComputerElement build(String CPU, String mainboard, String memory, String SSD, String power, String computerCase) {
return computerBuilder.buildMainboard(mainboard)
.buildCPU(CPU)
.buildSSD(SSD)
.buildMemory(memory)
.buildPower(power)
.buildComputerCase(computerCase)
.build();
}
}
Test：测试方法
public class Test {
public static void main(String[] args) {
ComputerDirector director = new ComputerDirector();
System.out.println(director.build("Intel酷睿六核处理器i5-8400","Intel B360","16G","1T","美商海盗船","机箱"));
}
}
输出结果：
电脑组装元件如下：
CPU：Intel酷睿六核处理器i5-8400
主板:Intel B360
内存：16G
SSD：1T
电源：美商海盗船
机箱：普通机箱
正在组装中...
组装完成！
二、通过静态内部类方式设计的建造者模式：
public class ComputerDIY {
private String CPU;
private String mainboard;
private String memory;
private String SSD;
private String power;
private String computerCase;
public ComputerDIY(ComputerBuilder computerBuilder) {
this.CPU = computerBuilder.CPU;
this.mainboard = computerBuilder.mainboard;
this.memory = computerBuilder.memory;
this.SSD = computerBuilder.SSD;
this.power = computerBuilder.power;
this.computerCase = computerBuilder.computerCase;
}
public String diy(){
final StringBuilder sb = new StringBuilder("电脑配置如下：\n");
sb.append(" CPU：")
.append(CPU).append('\n');
sb.append(" 主板:")
.append(mainboard).append('\n');
sb.append(" 内存：")
.append(memory).append('\n');
sb.append(" SSD：")
.append(SSD).append('\n');
sb.append(" 电源：")
.append(power).append('\n');
sb.append(" 机箱：")
.append(computerCase).append('\n');
sb.append("正在组装中...").append('\n');
sb.append("组装完成！").append('\n');
return sb.toString();
}
@Override
public String toString() {
final StringBuilder sb = new StringBuilder("{");
sb.append("\"CPU\":\"")
.append(CPU).append('\"');
sb.append(",\"mainboard\":\"")
.append(mainboard).append('\"');
sb.append(",\"memory\":\"")
.append(memory).append('\"');
sb.append(",\"SSD\":\"")
.append(SSD).append('\"');
sb.append(",\"power\":\"")
.append(power).append('\"');
sb.append('}');
return sb.toString();
}
public static class ComputerBuilder{
private String CPU;
private String mainboard;
private String memory;
private String SSD;
private String power;
private String computerCase;
public ComputerBuilder buildCPU(String CPU) {
this.CPU = CPU;
return this;
}
public ComputerBuilder buildMainboard(String mainboard) {
this.mainboard = mainboard;
return this;
}
public ComputerBuilder buildMemory(String memory) {
this.memory = memory;
return this;
}
public ComputerBuilder buildSSD(String SSD) {
this.SSD = SSD;
return this;
}
public ComputerBuilder buildPower(String power) {
this.power = power;
return this;
}
public ComputerBuilder buildComputerCase(String computerCase) {
this.computerCase = computerCase;
return this;
}
public ComputerDIY build() {
return new ComputerDIY(this);
}
}
}
public class Test {
public static void main(String[] args) {
ComputerDIY computerDIY = new ComputerDIY.ComputerBuilder()
.buildCPU("Intel酷睿六核处理器i5-8400")
.buildMainboard("Intel B360")
.buildMemory("16G")
.buildSSD("16G")
.buildPower("美商海盗船")
.buildComputerCase("普通机箱")
.build();
System.out.println(computerDIY.diy());
}
}
输出结果：
电脑配置如下：
CPU：Intel酷睿六核处理器i5-8400
主板:Intel B360
内存：16G
SSD：16G
电源：美商海盗船
机箱：普通机箱
正在组装中...
组装完成！
总结
建造者模式适合于创建的对象较复杂，由多个部件构成，各部件面临着复杂的变化，但构件间的建造顺序是稳定的；创建复杂对象的算法独立于该对象的组成部分以及它们的装配方式，即产品的构建过程和最终的表示是独立的。
网友评论