当前位置：首页 > news >正文

五、创建型（建造者模式）

news 2025/1/12 9:42:43

建造者模式

概念
建造者模式是一种创建型设计模式，通过使用多个简单的对象一步步构建一个复杂的对象。它将一个复杂对象的构建过程与其表示分离，从而使同样的构建过程可以创建不同的表示。

应用场景

复杂对象构建：当一个对象有多个属性，且这些属性的组合复杂时，例如配置文件的读取、复杂的界面元素等。
多个表示：需要构建的对象有不同的表示，且相同的构建过程可以生成不同的表示。
逐步构建：需要逐步构建对象，可能需要在不同的时间或不同的上下文中设置对象的属性。
不变性：当对象构建后需要保持不变的情况下，使用建造者模式可以清晰地定义对象的状态。

注意点

复杂性：建造者模式适用于构建复杂对象，但如果对象较简单，可能显得过于复杂。
灵活性：在构建对象时，如果需要频繁修改构建的顺序或逻辑，可能会导致建造者的实现复杂。
建造者责任：建造者的职责仅限于构建过程，避免将其他逻辑混入建造者中。

核心要素

产品：最终构建的复杂对象。
建造者接口：定义构建产品的各个部分的方法。
具体建造者：实现建造者接口，负责具体的构建逻辑。
指挥者：负责调用建造者的方法，控制构建过程。

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;}@Overridepublic 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();@Overridepublic void buildPartA() {product.setPartA("Part A");}@Overridepublic void buildPartB() {product.setPartB("Part B");}@Overridepublic 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;}@Overridepublic 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;}@Overridepublic String toString() {return "ComplexProduct [partA=" + partA + ", partB=" + partB + ", partC=" + partC + "]";}
}// 复杂建造者
class ComplexBuilder implements Builder {private ComplexProduct product = new ComplexProduct();@Overridepublic void buildPartA() {product.setPartA("Complex Part A");}@Overridepublic void buildPartB() {product.setPartB("Complex Part B");}public void buildPartC() {product.setPartC("Complex Part C");}@Overridepublic 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;}@Overridepublic 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();@Overridepublic void buildPartA() {product.setPartA("Builder A - Part A");}@Overridepublic void buildPartB() {product.setPartB("Builder A - Part B");}@Overridepublic MultiProduct getResult() {return product;}
}class BuilderB implements Builder {private MultiProduct product = new MultiProduct();@Overridepublic void buildPartA() {product.setPartA("Builder B - Part A");}@Overridepublic void buildPartB() {product.setPartB("Builder B - Part B");}@Overridepublic 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);}}
}