目标实现：
要求通过构建者模式和抽象工厂模式实现“造人计划”，方便起见，我们根据颜色将人种分类——Yellowman，
Whiteman，Blackman，Redman，Greenman and so on。
设计思路：
一、
生成一个完整的人主要经历两个主要环节，1、人体部件的生产。 2、人体部件的组装。先说说人体部件的生产，不管哪类人种，身体部件的数量都是一样的，他们的差异主要是在身体部件的形态上的差异，这里假设只存在颜色上的差异，这里假设将人只划分为Head，Body，Foot三部件，不同人种的部件上存在颜色上的差异。uml图如下。
Human类：
public class Human {
private Head head;
private Body body;
private Foot foot;
public Head getHead() {
return head;
}
public void setHead(Head head) {
this.head = head;
}
public Body getBody() {
return body;
}
public void setBody(Body body) {
this.body = body;
}
public Foot getFoot() {
return foot;
}
public void setFoot(Foot foot) {
this.foot = foot;
}
}
Foot抽象类：
public abstract class Foot {
public abstract void function();
}
Head抽象类：
public abstract class Head {
public abstract void function();
}
Body抽象类：
public abstract class Body {
public abstract void function();
}
继承的具体类：这里就不写，随便重写一下父类function()方法，输出不同的颜色值就可以了。
接着，我们改用抽象工厂模式来生成人体部件。为什么要用抽象工厂而不是普通工厂？我们都知道，抽象工厂模式相对于工厂模式多了一个叫做产品族的东西，在这里，人头，人躯，人脚都是产品，而它们的组合就叫是产品族了。如下就是抽象工厂的uml图。
1.FactoryProducer: 用于创建并获得工厂，也就是工厂的工厂。
public class FactoryProducer {
public AbstractHumanComponentFactory getFactory(String type) {
if ("head".equals(type)) {
return new HeadFactory();
}
if ("body".equals(type)) {
return new BodyFactory();
}
if ("foot".equals(type)) {
return new FootFactory();
}
return null;
}
}
2.AbstractHumanComponentFactory： 作为生产人体部件的抽象工厂，其子类是用于创建某一具体身体部件的工厂。
public abstract class AbstractHumanComponentFactory {
abstract public Head getHead(String type);
abstract public Body getBody(String type);
abstract public Foot getFoot(String type);
}
3.具体的人体部件工厂类,以生产人头的工厂
HeadFactory
为例：
public class HeadFactory extends AbstractHumanComponentFactory {
@Override
public Head getHead(String type) {
// TODO Auto-generated method stub
if ("black".equals(type)) {
return new BlackmanHead();
}
if ("white".equals(type)) {
return new WhitemanHead();
}
if(...){
....//生产其他颜色的人头。
} return null;
}
@Override
public Body getBody(String type) {
// TODO Auto-generated method stub
return null;
}
@Override
public Foot getFoot(String type) {
// TODO Auto-generated method stub
return null;
}
}
二、人体部件的工厂已经可以正常生产了，接下去要考虑人体的组装了。在这里创建者模式就能很好得发挥它的用场了，以下是菜鸟教程中对于该模式的介绍：
意图：将一个复杂的构建与其表示相分离，使得同样的构建过程可以创建不同的表示。
主要解决：主要解决在软件系统中，有时候面临着"一个复杂对象"的创建工作，其通常由各个部分的子对象用一定的算法构成；由于需求的变化，这个复杂对象的各个部分经常面临着剧烈的变化，但是将它们组合在一起的算法却相对稳定。
何时使用：一些基本部件不会变，而其组合经常变化的时候。
如何解决：将变与不变分离开。
关键代码：建造者：创建和提供实例，导演：管理建造出来的实例的依赖关系。
应用实例： 1、去肯德基，汉堡、可乐、薯条、炸鸡翅等是不变的，而其组合是经常变化的，生成出所谓的"套餐"。 2、JAVA 中的 StringBuilder。
优点： 1、建造者独立，易扩展。 2、便于控制细节风险。
缺点： 1、产品必须有共同点，范围有限制。 2、如内部变化复杂，会有很多的建造类。
使用场景： 1、需要生成的对象具有复杂的内部结构。 2、需要生成的对象内部属性本身相互依赖。
注意事项：与工厂模式的区别是：建造者模式更加关注与零件装配的顺序。
乍一看，云里雾里，似懂非懂，但是有一句深入人心，那就是“将变与不变分离开”。在“造人计划”中，人体结构始终都是不变的，一个人体结构始终由一个头，一个躯体，一双脚组成。但是变化的部分就是头，躯体，脚的差异性，正是这些差异构成了不同的人。这里已经我们把不变的部分给提取出来了，也就是上面的Human类。变化的部分也给提取出来了，它们是身体组件类的各个子类。但是我们如何把变化的部分与不变的部分衔接起来，组成我们想要的人，这里我们就需要构建者模式中另外两个角色来参与了——Builder和Director。Builder负责提供组装部件和返回成品的方法，但它自身不负责组装的执行，组装的执行交给Director来做。
Builder:
public abstract class HumanBuilder {
public abstract void buildHead();
public abstract void buildBody();
public abstract void buildFoot();
public abstract Human getHuman();
}
ConcreteBuilder:
public class WhitemanBuilder extends HumanBuilder{
private Human whiteman = new Human();
private FactoryProducer factoryProducer = new FactoryProducer();
@Override
public void buildHead() {
// TODO Auto-generated method stub
//这里通过上面实行的抽象工厂来获得部件
AbstractHumanComponentFactory headFactory = factoryProducer.getFactory("head");
whiteman.setHead(headFactory.getHead("white"));
}
@Override
public void buildBody() {
// TODO Auto-generated method stub
//这里通过上面实现的抽象工厂来获得部件
AbstractHumanComponentFactory bodyFactory = factoryProducer.getFactory("body");
whiteman.setBody(bodyFactory.getBody("white"));
}
@Override
public void buildFoot() {
// TODO Auto-generated method stub
//这里通过上面实现的抽象工厂方法来获得部件
AbstractHumanComponentFactory footFactory = factoryProducer.getFactory("foot");
whiteman.setFoot(footFactory.getFoot("white"));
}
@Override
public Human getHuman() {
// TODO Auto-generated method stub
return this.whiteman;
}
}public class BlackmanBuilder extends HumanBuilder {
private Human blackman = new Human();
private FactoryProducer factoryProducer = new FactoryProducer();
public void buildHead() {
// TODO Auto-generated method stub
AbstractHumanComponentFactory headFactory = factoryProducer.getFactory("head");
blackman.setHead(headFactory.getHead("black"));
}
public void buildBody() {
// TODO Auto-generated method stub
AbstractHumanComponentFactory bodyFactory = factoryProducer.getFactory("body");
blackman.setBody(bodyFactory.getBody("black"));
}
public void buildFoot() {
// TODO Auto-generated method stub
AbstractHumanComponentFactory footFactory = factoryProducer.getFactory("foot");
blackman.setFoot(footFactory.getFoot("black"));
}
public Human getHuman() {
// TODO Auto-generated method stub
return this.blackman;
}
}
Director:
public class HumanDirector {
private HumanBuilder humanBuilder;
public void setHumanBuilder(HumanBuilder humanBuilder) {
this.humanBuilder = humanBuilder;
}
public HumanDirector() {
super();
}
public HumanDirector(HumanBuilder humanBuilder) {
super();
this.humanBuilder = humanBuilder;
}
// 只负责构建不负责返回
public void construct() {
humanBuilder.buildHead();
humanBuilder.buildBody();
humanBuilder.buildFoot();
}
}
客户端调用：
public static void main(String[] args) {
BlackmanBuilder blackmanBuilder = new BlackmanBuilder();
HumanDirector blackmanDirector = new HumanDirector(blackmanBuilder);
blackmanDirector.construct();
Human blackman = blackmanBuilder.getHuman();
System.out.println("black man performs------------");
blackman.getHead().function();
blackman.getBody().function();
blackman.getFoot().function();
WhitemanBuilder whitemanBuilder = new WhitemanBuilder();
HumanDirector whitemanDirector = new HumanDirector(whitemanBuilder);
whitemanDirector.construct();
Human whiteman = whitemanBuilder.getHuman();
System.out.println("white man performs------------");
whiteman.getHead().function();
whiteman.getBody().function();
whiteman.getFoot().function();
}
构建者模式的uml图：
构建者模式和抽象工厂模式整合后的uml图（画得有点乱）：
总结：
傻傻地加一条工厂方法模式和构建者模式之间的差别吧：
我门可以观察到，工厂模式返回的多个对象中，对象与对象之间存在着类的差异，通常不同的对象都是不同子类的实例化。而构建者模式返回的多个对象，这些对象通常都是同一个类的实例化，只是这些对象内部的组合存在着差异。
