生成器模式浅谈

  生成器的定义：

        将一个复杂对象的构建与它的表现分离，使得同样的构建过程可以创建不同的表示。

  应用场景：

     
1、当创建复杂对象的算法应该独立于对象的组成部分以及它们的装配方式时；

      2、当构造过程必须允许被构造的对象有不同的表示时；

 
结构图如下：

       



      以农场生产各种花为例（java）：

package builderModel.flower;

//生成器模式:创建各式各样的花
public class Flower {
private String stem;// 花朵的茎：为简单只定位String类型，可具体写成一个类
private String leaf;// 叶子,同上
private String flower;// 花，同上

public Flower() {
System.out.println("得到一种花：");
}

public String getStem() {
return stem;
}

public void setStem(String stem) {
this.stem = stem;
}

public String getLeaf() {
return leaf;
}

public void setLeaf(String leaf) {
this.leaf = leaf;
}

public String getFlower() {
return flower;
}

public void setFlower(String flower) {
this.flower = flower;
}

@Override
public String toString() {
return "Flower [flower=" + flower + ", leaf=" + leaf + ", stem=" + stem
+ "]";
}

}

package builderModel.flower;

//抽象的生成器，用于生成花
public abstract class Builder {

abstract void builderStem();
abstract void builderLeaf();
abstract void builderFlower();
public Flower getFlower(){
return null;
}
}

package builderModel.flower;

//具体的花：玫瑰花生成器
public class RoseBuilder  extends Builder {

Flower rose=new Flower();
void builderFlower() {
rose.setFlower("花朵-大红大白，半径5厘米");
}

void builderLeaf() {
rose.setLeaf("叶-圆形");
}
void builderStem() {
rose.setStem("茎-5厘米");
}

public Flower getFlower(){
return rose;
}

}

package builderModel.flower;

//向导器，封装创建过程
public class Director {

public void createFlower(Builder builder) {
builder.builderFlower();
builder.builderLeaf();
builder.builderStem();
builder.getFlower();
}
}

package builderModel.flower;

//测试
public class Client {

public static void main(String[] args){
Director dir=new Director();
Builder b=new RoseBuilder();//一种花一种具体生成器
dir.createFlower(b);
Flower rose=b.getFlower();
System.out.println(rose);

}
}

控制台结果：
    得到一种花：

     Flower [flower=花朵-大红大白，半径5厘米, leaf=叶-圆形, stem=茎-5厘米]

  生成器模式优点：

        1、将一个复杂对象的创建过程封装起来。这里我们将每一个对象“可能”的创建过程封装在具体生成器实现类中。

        2、允许对象通过多个步骤来创建，并且可以改变过程。这里我们可以通过Client来改变（自由搭配）对象的创建步骤，而不是像其它工厂模式一样只有一个步骤。这也就是定义中提到的同样的创建过程可以创建不同的表示。

        3、向客户隐藏产品的内部实现。

        4、产品的实现可以被替换，因为客户只看到一个抽象的接口。