生成器模式 创建型模式

点击打开链接1）生成器模式：将复杂对象的表示和创建进行分离。

抽象工厂和工厂模式，都是进行完成一个或是一系列的对象创建，如果是针对一个对象的创建较为复杂，需要多部分组装。

此时需要用建造者模式。

2）一个对象有多个部分进行构建，构建算法按需求变化，每一个构建模块相对稳定。

此时，生成器模式可以达到封装，让内部变化，而对外不影响。

3）构建图：

1、抽象生成器（builder）：为创建一个Product对象的各个部件指定的抽象接口。

2、生成器具体实现

3、指导者

4、产品

5、客户端

代码案例：

:  public abstract class Builder{
 2:      public abstract void buildPartA();
 3:      public abstract void buildPartB();
 4:      public abstract Product getProduct();
 5:  }
 6:   
 7:  public class ConcreteBuilder1 extends Builder{
 8:      private Product product;
 9:      public void buildPartA(){
10:          product.addPart("PartA");
11:      }
12:      public void buildPartB(){
13:          product.addPart("PartB");
14:      }
15:   
16:      public Product getProduct(){
17:          if(product!=null)
18:              return product;
19:          else 
20:              return null;
21:      }
22:  }
23:   
24:  public class ConcreteBuilder2 extends Builder{
25:      private Product product;
26:      public void buildPartA(){
27:          product.addPart("PartX");
28:      }
29:      public void buildPartB(){
30:          product.addPart("PartY");
31:      }
32:   
33:      public Product getProduct(){
34:          if(product!=null)
35:              return product;
36:          else 
37:              return null;
38:      }
39:  }
40:   
41:  public class Director{
42:      public void construct(Builder builder){
43:          builder.buildPartA();
44:          builder.buildPartB();
45:      }
46:  }
47:   
48:  public class Product{
49:      private ArrayList<String> product;
50:      public void addPart(String partName){
51:          product.add(partName);
52:      }
53:   
54:      public void showProduct(){
55:          for (String part : product) {
56:              System.out.println(part);
57:          }
58:      }
59:   
60:  }
61:   
62:  public class Client{
63:      public static void main(String[] args){
64:          Director director=new Director();
65:   
66:          Builder concreteBuilder1=new ConcreteBuilder1();
67:          director.construct(concreteBuilder1);
68:          Product product1=concreteBuilder1.getProduct();
69:          product1.showProduct();
70:   
71:          Builder concreteBuilder2=new ConcreteBuilder2();
72:          director.construct(concreteBuilder2);
73:          Product product2=concreteBuilder2.getProduct();
74:          product2.showProduct();        
75:      }
76:  }

现实场景

其实，在现实场景中，有很多适用于生成器模式来解决的应用。比如Terrylee所描述的 KFC场景 ，这种模式用于快餐店制作儿童餐。典型的儿童餐包括一个主食，一个辅食，一杯饮料和一个玩具（例如汉堡、炸鸡、可乐和玩具车）。 这些在不同的儿童餐中可以是不同的 ，但是 组合成儿童餐的过程是相同的 （这是关键点）。无论顾客点的是汉堡，三名治还是鸡肉，过程都是一样的。柜台的员工直接把主食，辅食和玩具放在一起。这些是放在一个袋子中的。饮料被倒入杯中，放在袋子外边。这些过程在相互竞争的餐馆中是同样的。在这样一种场景中，主食、辅食、饮料和玩具根据所选择的套餐种类的不同而不同，但是不管何种套餐，都具有这几大部分，也就是说组装的过程是一致的，不同的只是子部分的实现不同而已，但是这并不妨碍子部分的组装流程。这不完全符合生成器模式的适用场景吗？

在生成器模式中，我们不轻易改变的是面向客户的那一个Director ，而是来实现不同的ConcreteBuilder 

比如儿童餐，有主食， 菜， 汤，玩具，那么在主食中，可以有米饭，馒头，菜品：蔬菜，红烧肉，汤：蛋花汤，等

这样就给出多个实现 ConcreteBuilder的实现，此时面向客户端的就不变了。 

这里不进行扩展，客户端点不同的套餐的情况。仅仅是进行扩展固定的一个主食，一个菜品，一个汤的情况！

总结： 对象的表示也可以抽象为总体的行为。或是创建也可以抽象成表示。也就是将复杂对象的行为分层，或表示分层。

行为 就是表示！ 将复杂对象分层创建。

 

参考：点击打开链接https://www.cnblogs.com/JackyTecblog/archive/2012/09/20/2695429.html