目标实现:
要求通过构建者模式和抽象工厂模式实现“造人计划”,方便起见,我们根据颜色将人种分类——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);
}
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、需要生成的对象内部属性本身相互依赖。
注意事项:与工厂模式的区别是:建造者模式更加关注与零件装配的顺序。
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图(画得有点乱):
总结:
傻傻地加一条工厂方法模式和构建者模式之间的差别吧:
我门可以观察到,工厂模式返回的多个对象中,对象与对象之间存在着类的差异,通常不同的对象都是不同子类的实例化。而构建者模式返回的多个对象,这些对象通常都是同一个类的实例化,只是这些对象内部的组合存在着差异。