Abstract Factory + Template = Builder

不对，呵呵

builder模式的核心就是Director类，实际上有一个Director类，它就是builder模式，呵呵

如果我们把Banq的以下代码

public interface Builder {
//创建部件A 比如创建汽车车轮
void buildPartA();
//创建部件B 比如创建汽车方向盘
void buildPartB();
//创建部件C 比如创建汽车发动机
void buildPartC();
//返回最后组装成品结果(返回最后装配好的汽车)
//成品的组装过程不在这里进行,而是转移到下面的Director 类中
进行.
//从而实现了解耦过程和部件
Product getResult();
}

public class Director {
private Builder builder;
public Director( Builder builder ) {
this.builder = builder;
}
public void construct() {
builder.buildPartA();
builder.buildPartB();
builder.buildPartC();
}
}
=============================

如果我们把Banq的以上代码整合成这样：

public abstract class Builder {

public abstract void buildPartA(){};
public abstract void buildPartB(){};
public abstract void buildPartC(){};

public void construct(){
this.buildPartA();
this.buildPartB();
this.buildPartC();
}

public abstract Product getResult(){};
}

public class ConcretBuilder extends Builder{
private Product product;
public void buildPartA(){这里是具体如何构建partA 的代码};
public void buildPartB(){这里是具体如何构建partB 的代码};
public void buildPartC(){这里是具体如何构建partC 的代码};

public Product getResult(){返回最后组装成品结果}

}

----
Client does like this way:

ConcreteBuilder concretebuilder = new ConcreteBuilder();
concretebuilder.construct();
Product product = concretebuilder.getResult();

----

因此，
we can take the concreteBuilder as a concreteFactory,
Builder as a abstractFactory

The difference is that
In Builder class, there is some common thing: construct(), 这个construct()的东东也可能看做Template模式中的核心.

请多发表意见，多谢！

基本同意你的观点。
如果builder模式省略掉director，那么就和template很相似了。construct（）方法相当于模版方法，而buildPartA，B（）等方法可推迟到子类实现。
但builder模式着重按步骤去创建一个复杂对象，而抽象工厂模式侧重创建多个系列的对象，builder是在各个步骤以后生成一个对象，抽象工厂则立刻产生一个对象，两者侧重点不同。

iyshang

同意你简单明了的总结.

其实我们可以通过模式的变形来去更深刻的认识模式，尤其是易混淆的模式,这样才能真正为我们所用。希望以后多交流。

不同意见，呵呵

builder模式就是builder模式，去掉Director类，它就不是builder模式

builder模式是强调产品是分步得到的

template模式强调的是继承的方法有点象模板，就象servlet的service()方法

Abstract Factory模式强调的是抽象的产品簇的问题

我觉的，非要把它们扯到一起来，并没有什么实际意义，呵呵！

大家的板砖准备好，^_^

richardluopeng:

其实也不是要把各种模式扯到一起来，只是想通过这种方式消化一下罢了。模不模式并不是目的，只是手段，对于我们来说，关键是这种模式在什么背景下产生，通过什么方式达到了什么目的，它的优且点的什么。
这样在我们做设计时才能为我所用，而不是硬生生的用某种模式来复杂化不必要的代码。

板砖这里不好找，我只是刚把脚上的鞋脱了，哈，开个玩笑。

Abstract Factory 是一个重量级的模式，抽象工厂，抽象产品，至少会牵涉8个类，呵呵，

Template至少有两个类，加在一起，至少是有十个类，人可以控制的混乱度是7左右，所以我觉得我是不愿意把它们联合使用

至于 Abstract Factory + Template = Builder，也是builder模式可以退化成Template ，和有没有Abstract Factory 并没有多大关系。

继续讨论，谢谢！

怎么不 讨论了？？

To richardluopeng,
你说的是对的, 各人有不同的理解方式,关键是弄懂能写代码就行.
最近在琢磨OR-Mapping, 有个叫ambler的老外写了一堆相关的文章,大家都可以看看. www.ambysoft.com

To Bruce,
你在公式中的Abstract Factory容易和抽象工厂模式混淆。
我明白你所谓的抽象工厂的意思，具体工厂的父类便是抽象工厂。
你看看《Java与模式》中的抽象工厂模式就知道了。
我同意你的观点，在AbstractBuilder的construct方法中是模板方法的极好的应用场合，在这个方法中统观全局地指出了建造一个产品的基本步骤。而这些基本步骤要在具体子类中实现。
abstract public AbstractBuilder {
abstract protected void buildPart1();
abstract protected void buildPart2();
public Product construct() {
buildPart1();
buildPart2();
// 把零部件组装成产品，并返回产品
}
}

public final ConcreteBuilder {
public void buildPart1() {...}
public void buildPart2() {...}
}
我觉得Director角色实在可以省略不要，完全没有必要。

无条件同意! 多谢

这个帖子在2008年继续顶.是个好帖子.基本上把 模板 builder Factory 3者的区别都说清楚了...谢谢大虾学习ing

public void construct(){
this.buildPartA();
this.buildPartB();
this.buildPartC();
}
Builder应该只包含构件子部件的方法.
楼主将construct方法放在builder里,在里面build partA,partB,partC.如果要创建另一个对象包含两个partA呢?

[该贴被greyson于2009-02-05 14:52修改过]

赞同！
有了Director这个组装类，就是builder模式了