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();
}

public abstract class Body {public abstract void function();
}

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;}
}

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 {@Overridepublic Head getHead(String type) {// TODO Auto-generated method stubif ("black".equals(type)) {return new BlackmanHead();}if ("white".equals(type)) {return new WhitemanHead();}

      if(...){

          ....//生产其他颜色的人头。

     }

       return null;}@Overridepublic Body getBody(String type) {// TODO Auto-generated method stubreturn null;}@Overridepublic Foot getFoot(String type) {// TODO Auto-generated method stubreturn null;}}

二、人体部件的工厂已经可以正常生产了，接下去要考虑人体的组装了。在这里创建者模式就能很好得发挥它的用场了，以下是菜鸟教程中对于该模式的介绍：

介绍

意图：将一个复杂的构建与其表示相分离，使得同样的构建过程可以创建不同的表示。

主要解决：主要解决在软件系统中，有时候面临着"一个复杂对象"的创建工作，其通常由各个部分的子对象用一定的算法构成；由于需求的变化，这个复杂对象的各个部分经常面临着剧烈的变化，但是将它们组合在一起的算法却相对稳定。

何时使用：一些基本部件不会变，而其组合经常变化的时候。

如何解决：将变与不变分离开。

关键代码：建造者：创建和提供实例，导演：管理建造出来的实例的依赖关系。

应用实例： 1、去肯德基，汉堡、可乐、薯条、炸鸡翅等是不变的，而其组合是经常变化的，生成出所谓的"套餐"。 2、JAVA 中的 StringBuilder。

优点： 1、建造者独立，易扩展。 2、便于控制细节风险。

缺点： 1、产品必须有共同点，范围有限制。 2、如内部变化复杂，会有很多的建造类。

使用场景： 1、需要生成的对象具有复杂的内部结构。 2、需要生成的对象内部属性本身相互依赖。

注意事项：与工厂模式的区别是：建造者模式更加关注与零件装配的顺序。

乍一看，云里雾里，似懂非懂，但是有一句深入人心，那就是“将变与不变分离开”。在“造人计划”中，人体结构始终都是不变的，一个人体结构始终由一个头，一个躯体，一双脚组成。但是变化的部分就是头，躯体，脚的差异性，正是这些差异构成了不同的人。这里已经我们把不变的部分给提取出来了，也就是上面的Human类。变化的部分也给提取出来了，它们是身体组件类的各个子类。但是我们如何把变化的部分与不变的部分衔接起来，组成我们想要的人，这里我们就需要构建者模式中另外两个角色来参与了——Builder和Director。Builder负责提供组装部件和返回成品的方法，但它自身不负责组装的执行，组装的执行交给Director来做。

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();@Overridepublic void buildHead() {// TODO Auto-generated method stub

       //这里通过上面实行的抽象工厂来获得部件AbstractHumanComponentFactory headFactory = factoryProducer.getFactory("head");whiteman.setHead(headFactory.getHead("white"));}@Overridepublic void buildBody() {// TODO Auto-generated method stub

       //这里通过上面实现的抽象工厂来获得部件AbstractHumanComponentFactory bodyFactory = factoryProducer.getFactory("body");whiteman.setBody(bodyFactory.getBody("white"));}@Overridepublic void buildFoot() {// TODO Auto-generated method stub

       //这里通过上面实现的抽象工厂方法来获得部件AbstractHumanComponentFactory footFactory = factoryProducer.getFactory("foot");whiteman.setFoot(footFactory.getFoot("white"));}@Overridepublic Human getHuman() {// TODO Auto-generated method stubreturn this.whiteman;}}

public class BlackmanBuilder extends HumanBuilder {private Human blackman = new Human();private FactoryProducer factoryProducer = new FactoryProducer();public void buildHead() {// TODO Auto-generated method stubAbstractHumanComponentFactory headFactory = factoryProducer.getFactory("head");blackman.setHead(headFactory.getHead("black"));}public void buildBody() {// TODO Auto-generated method stubAbstractHumanComponentFactory bodyFactory = factoryProducer.getFactory("body");blackman.setBody(bodyFactory.getBody("black"));}public void buildFoot() {// TODO Auto-generated method stubAbstractHumanComponentFactory footFactory = factoryProducer.getFactory("foot");blackman.setFoot(footFactory.getFoot("black"));}public Human getHuman() {// TODO Auto-generated method stubreturn 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图（画得有点乱）：

总结：