五、创建型（建造者模式）
建造者模式
概念
建造者模式是一种创建型设计模式，通过使用多个简单的对象一步步构建一个复杂的对象。它将一个复杂对象的构建过程与其表示分离，从而使同样的构建过程可以创建不同的表示。
应用场景
- 复杂对象构建：当一个对象有多个属性，且这些属性的组合复杂时，例如配置文件的读取、复杂的界面元素等。
- 多个表示：需要构建的对象有不同的表示，且相同的构建过程可以生成不同的表示。
- 逐步构建：需要逐步构建对象，可能需要在不同的时间或不同的上下文中设置对象的属性。
- 不变性：当对象构建后需要保持不变的情况下，使用建造者模式可以清晰地定义对象的状态。
注意点
- 复杂性：建造者模式适用于构建复杂对象，但如果对象较简单，可能显得过于复杂。
- 灵活性：在构建对象时，如果需要频繁修改构建的顺序或逻辑，可能会导致建造者的实现复杂。
- 建造者责任：建造者的职责仅限于构建过程，避免将其他逻辑混入建造者中。
核心要素
- 产品：最终构建的复杂对象。
- 建造者接口：定义构建产品的各个部分的方法。
- 具体建造者：实现建造者接口，负责具体的构建逻辑。
- 指挥者：负责调用建造者的方法，控制构建过程。
Java代码示例
// 产品
class Product {
private String partA;
private String partB;
public void setPartA(String partA) {
this.partA = partA;
}
public void setPartB(String partB) {
this.partB = partB;
}
@Override
public String toString() {
return "Product [partA=" + partA + ", partB=" + partB + "]";
}
}
// 建造者接口
interface Builder {
void buildPartA();
void buildPartB();
Product getResult();
}
// 具体建造者
class ConcreteBuilder implements Builder {
private Product product = new Product();
@Override
public void buildPartA() {
product.setPartA("Part A");
}
@Override
public void buildPartB() {
product.setPartB("Part B");
}
@Override
public Product getResult() {
return product;
}
}
// 指挥者
class Director {
private Builder builder;
public Director(Builder builder) {
this.builder = builder;
}
public void construct() {
builder.buildPartA();
builder.buildPartB();
}
}
// 客户端
public class Client {
public static void main(String[] args) {
Builder builder = new ConcreteBuilder();
Director director = new Director(builder);
director.construct();
Product product = builder.getResult();
System.out.println(product);
}
}
各种变形用法
- 使用链式方法
可以在建造者中使用链式方法，简化代码。
// 产品
class Product {
private String partA;
private String partB;
public void setPartA(String partA) {
this.partA = partA;
}
public void setPartB(String partB) {
this.partB = partB;
}
@Override
public String toString() {
return "Product [partA=" + partA + ", partB=" + partB + "]";
}
}
// 建造者（链式方法）
class BuilderWithChain {
private Product product = new Product();
public BuilderWithChain buildPartA() {
product.setPartA("Part A");
return this;
}
public BuilderWithChain buildPartB() {
product.setPartB("Part B");
return this;
}
public Product build() {
return product;
}
}
// 客户端
public class ClientChain {
public static void main(String[] args) {
BuilderWithChain builder = new BuilderWithChain();
Product product = builder.buildPartA().buildPartB().build();
System.out.println(product);
}
}
- 复杂建造者
为不同类型的产品创建不同的建造者。
// 产品
class ComplexProduct {
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;
}
@Override
public String toString() {
return "ComplexProduct [partA=" + partA + ", partB=" + partB + ", partC=" + partC + "]";
}
}
// 复杂建造者
class ComplexBuilder implements Builder {
private ComplexProduct product = new ComplexProduct();
@Override
public void buildPartA() {
product.setPartA("Complex Part A");
}
@Override
public void buildPartB() {
product.setPartB("Complex Part B");
}
public void buildPartC() {
product.setPartC("Complex Part C");
}
@Override
public ComplexProduct getResult() {
return product;
}
}
// 客户端
public class ClientComplex {
public static void main(String[] args) {
ComplexBuilder builder = new ComplexBuilder();
builder.buildPartA();
builder.buildPartB();
builder.buildPartC();
ComplexProduct product = builder.getResult();
System.out.println(product);
}
}
- 多建造者
可以同时使用多个建造者来构建产品的不同部分。
// 产品
class MultiProduct {
private String partA;
private String partB;
public void setPartA(String partA) {
this.partA = partA;
}
public void setPartB(String partB) {
this.partB = partB;
}
@Override
public String toString() {
return "MultiProduct [partA=" + partA + ", partB=" + partB + "]";
}
}
// 建造者接口
interface Builder {
void buildPartA();
void buildPartB();
MultiProduct getResult();
}
// 具体建造者
class BuilderA implements Builder {
private MultiProduct product = new MultiProduct();
@Override
public void buildPartA() {
product.setPartA("Builder A - Part A");
}
@Override
public void buildPartB() {
product.setPartB("Builder A - Part B");
}
@Override
public MultiProduct getResult() {
return product;
}
}
class BuilderB implements Builder {
private MultiProduct product = new MultiProduct();
@Override
public void buildPartA() {
product.setPartA("Builder B - Part A");
}
@Override
public void buildPartB() {
product.setPartB("Builder B - Part B");
}
@Override
public MultiProduct getResult() {
return product;
}
}
// 多建造者指挥者
class MultiBuilderDirector {
private List<Builder> builders;
public MultiBuilderDirector(List<Builder> builders) {
this.builders = builders;
}
public void constructAll() {
for (Builder builder : builders) {
builder.buildPartA();
builder.buildPartB();
}
}
}
// 客户端
public class ClientMulti {
public static void main(String[] args) {
List<Builder> builders = new ArrayList<>();
builders.add(new BuilderA());
builders.add(new BuilderB());
MultiBuilderDirector director = new MultiBuilderDirector(builders);
director.constructAll();
for (Builder builder : builders) {
MultiProduct product = builder.getResult();
System.out.println(product);
}
}
}
下面是几种建造者模式的变形用法的完整例子，展示了如何使用链式方法、复杂建造者和多建造者。
原文地址：https://blog.csdn.net/xiaoqi270620903/article/details/142831933
免责声明：本站文章内容转载自网络资源，如本站内容侵犯了原著者的合法权益，可联系本站删除。更多内容请关注自学内容网（zxcms.com）！