GoF 23个经典的设计模式02--创建模式之创建者模式（未完代续）

创建者模式：分离创建复杂对象和构造/初始化对象的方法。
Separate the construction of a complex object from its representation so that the same construction process can create different representations. [GoF, p97]

我这个翻译可能比较抽象，打个比方生产汽车。我们都知道汽车由轮子，门和灯组成。我们想要一辆汽车，如果一个人做那么肯定会累死。所以我们请创建者Builder创建各个部件，而指导者Director只需要指导创建部件的步骤就可以了。

还是看一下设计手稿


UML整理


这个图和我用JAVA  实现的离子不太一样。

我更依造设计模式本身的含义去对各个对象命名。

首先还是看Client怎么调用

package  org.benewu.patterns.builder;

import  java.util.Iterator;
import  java.util.List;

public   class  Client  ... {

    public static void main(String[] args) ...{
        
        Builder builder = new ConcreteBuilder();
        Director director = new Director(builder);
        //director指导builder生产
        director.construct();
        //从builder处得到产品对象
        Product product = builder.getResult();
        
        List partList = product.getParts();
        for (Iterator iter = partList.iterator(); iter.hasNext();) ...{
            Part element = (Part) iter.next();
            System.out.println(element.getPartName());
        }
    }
}

抽象工人Builder以及具体实现,工人只关心怎么建造部件

package  org.benewu.patterns.builder;

public   interface  Builder  ... {

    public void buildPartA();
    public void buildPartB();

    public Product getResult();
}

package  org.benewu.patterns.builder;

public   class  ConcreteBuilder  implements  Builder  ... {

    Part partA,partB;
    Product productA = new ProductA();
    
    public void buildPartA() ...{
        
        partA = new PartA();
        partA.makePartName();
        productA.addPart(partA);
    }

    public void buildPartB() ...{
        partB = new PartB();
        partB.makePartName();
        productA.addPart(partB);
    }

    public Product getResult() ...{
        return productA;
    }
}

指导者Director指导工人Builder装配

package  org.benewu.patterns.builder;

public   class  Director  ... {

    private Builder builder;
    public Director(Builder builder)...{
        this.builder = builder;
    }
    
    //指导装配
    public void construct()...{
        builder.buildPartA();
        builder.buildPartB();
    }
}

最后再定义抽象产品和它的实现

package  org.benewu.patterns.builder;

import  java.util.ArrayList;
import  java.util.List;

public   abstract   class  Product  ... {

    protected List<Part>  parts = new ArrayList<Part>();
    
    public abstract void addPart(Part part);

    public List getParts() ...{
        return parts;
    }
    
    
}

package  org.benewu.patterns.builder;

public   class  ProductA  extends  Product  ... {

    @Override
    public void addPart(Part part) ...{
        
        this.parts.add(part);

    }

}

产品的各个部件

package  org.benewu.patterns.builder;

public   abstract   class  Part  ... {
    
    private String partName;
    
    public abstract void makePartName();

    public String getPartName() ...{
        return partName;
    }

    public void setPartName(String partName) ...{
        this.partName = partName;
    }
    
}

package  org.benewu.patterns.builder;

public   class  PartA  extends  Part  ... {

    public void makePartName() ...{
        setPartName("org.patterns.builder.PartA");
    }

}

package  org.benewu.patterns.builder;

public   class  PartB  extends  Part  ... {

    @Override
    public void makePartName() ...{
        setPartName("org.patterns.builder.PartB");
    }

}

可能比较抽象，这有个生动的例子： 我们去快餐店买套餐。收银员不知道汉堡，薯条，可乐怎么做，厨师不知道一个什么套餐有哪些。如果我们要一个儿童套餐，还要带一个玩具汽车。
那么怎么办呢？事情是这样的，我们Client说要一个儿童套餐，然后收银员Director打了个套餐配件表拿到厨房，厨师Builder根据配件表做好汉堡薯条，装上可乐汽车，再返回回来。我们就得到了一个儿童套餐。



Builder用来创建复杂的对象，在哪里用过或者见到过吗？

-----------
参考资料：
http://home.earthlink.net/~huston2/dp/patterns.html
http://www.jdon.com/designpatterns/index.htm