BuilderPattern（23种设计模式之一）

---

设计模式六大原则（1）：单一职责原则 设计模式六大原则（2）：里氏替换原则 设计模式六大原则（3）：依赖倒置原则 设计模式六大原则（4）：接口隔离原则 设计模式六大原则（5）：迪米特法则 设计模式六大原则（6）：开闭原则

BuilderPattern，UML抽象图百度找，代码实现如下

使用生成器模式设计一个构造复杂类的过程。

抽象生成器

package BuilderPattern;
public interface IVehicleBuilder {
    public void buildPartA();
    public void buildPartB();
    public Product getProduct();
}

具体生成器

package BuilderPattern.ConcreteBuilder;
import BuilderPattern.IVehicleBuilder;
import BuilderPattern.Product;
public class ConcreteBuilder1 implements IVehicleBuilder {
    private Product product = new Product();
    public void buildPartA() {
        // TODO Auto-generated method stub
        product.addPart("PartA");
    }

    public void buildPartB() {
        // TODO Auto-generated method stub
        product.addPart("PartB");
    }

    public Product getProduct() {
        // TODO Auto-generated method stub
        if(product!=null)
            return product;
        else
            return null;
    }
    
}

package BuilderPattern.ConcreteBuilder;
import BuilderPattern.IVehicleBuilder;
import BuilderPattern.Product;
public class ConcreteBuilder2 implements IVehicleBuilder {
    private Product product = new Product();
    public void buildPartA() {
        // TODO Auto-generated method stub
        product.addPart("PartX");
    }

    public void buildPartB() {
        // TODO Auto-generated method stub
        product.addPart("PartY");
    }

    public Product getProduct() {
        // TODO Auto-generated method stub
        if(product!=null)
            return product;
        else
            return null;
    }

}

指导者

package BuilderPattern;
public class Director {
     public void construct(IVehicleBuilder builder){
         builder.buildPartA();
         builder.buildPartB();
     }
}

具体产品

package BuilderPattern;
import java.util.ArrayList;
public class Product {
    private ArrayList<String> product = new ArrayList<String>();
    public void addPart(String partName){
         product.add(partName);
    }
    public void showProduct(){
         for (String part : product) {
             System.out.println(part);
         }
    }
}

测试类

package BuilderPattern;
import BuilderPattern.ConcreteBuilder.ConcreteBuilder1;
import BuilderPattern.ConcreteBuilder.ConcreteBuilder2;
public class Test {

    public static void main(String[] args) {
        
        // TODO Auto-generated method stub
         Director director=new Director();     //指导者，指导具体生成器构造产品
         /*
          * 生成AB
          * */
         IVehicleBuilder concreteBuilder1=new ConcreteBuilder1();
         director.construct(concreteBuilder1);
         Product product1=concreteBuilder1.getProduct();
         product1.showProduct();
         /*
          * 生成XY
          * */
         IVehicleBuilder concreteBuilder2=new ConcreteBuilder2();
         director.construct(concreteBuilder2);
         Product product2=concreteBuilder2.getProduct();
         product2.showProduct(); 
    }

}

---

在实际的软件系统中，各个子部分对象完全有可能通过相应的工厂方法来生成，然后再交由生成器按照特定的构建算法将其组装成一个完整的“复杂对象”。

---

生成器模式的本质：分离整体构建算法和部件构造表示。构建一个复杂对象，需要将整体的构建过程与复杂对象子部件的构建过程分离开来，这样才能使得程序结构更松散、易扩展，复用性好，同样也会使代码逻辑更清晰，意图更明显。生成器模式的重心还是在于分离整体构建算法与子部件的构建，分步骤构建对象只不过是整体构建算法的一个简单表现，或者说是一个附带产物。

---

别嫌弃我没写注释，这个代码很简单，注释省略，嘿嘿。

转载于:https://www.cnblogs.com/1996jiwei/p/6490819.html