黑马程序员 java 设计模式之 工厂方法

　------- <a href="http://www.itheima.com" target="blank">android培训</a>、<a href="http://www.itheima.com" target="blank">java培训</a>、期待与您交流！ ----------

女娲补天的故事大家都听说过吧,今天不说这个,说女娲创造人的故事,可不是“造人”的工作,这个词被现代人滥用了。这个故事是说,女娲在补了天后,下到凡间一看,哇塞,风景太优美了,天空是湛蓝的,水是清澈的,空气是清新的,太美丽了,然后就待时间长了就有点寂寞了,没有动物,这些看的到都是静态的东西呀,怎么办?

别忘了是神仙呀,没有办不到的事情,于是女娲就架起了八卦炉(技术术语:建立工厂)开始创建人,具体过程是这样的:先是泥巴捏,然后放八卦炉里烤,再扔到地上成长,但是意外总是会产生的:第一次烤泥人,兹兹兹兹~~,感觉应该熟了,往地上一扔,biu~,一个白人诞生了,没烤熟!

第二次烤泥人,兹兹兹兹兹兹兹兹~~,上次都没烤熟,这次多烤会儿,往地上一扔,嘿,熟过头了,黑人哪!

第三次烤泥人,兹~兹~兹~,一边烤一边看着,嘿,正正好,Perfect!优品,黄色人类!【备注:RB 人不属此列】

这个过程还是比较有意思的,先看看类图:(之前在论坛上有兄弟建议加类图和源文件,以后的模式都会加上去,之前的会一个一个的补充,目的是让大家看着舒服,看着愉悦,看着就想要,就像是看色情小说一样,目标,目标而已,能不能实现就看大家给我的信心了)

  那这个过程我们就用程序来表现,首先定义一个人类的总称:

packagecom.cbf4life;

/**
* I'm glad to share my knowledge with you all.* 定义一个人类的统称
*/

public interfaceHuman {//首先定义什么是人类

//人是愉快的,会笑的,本来是想用smile表示,想了一下laugh更合适,好长时间没有大笑了;public void laugh();

//人类还会哭,代表痛苦public void cry();

//人类会说话
public voidtalk();

}

然后定义具体的人类:

packagecom.cbf4life;

/**
* @authorcbf4Life [e-mail]
* I'm glad to share my knowledge with you all.* 黄色人类,这个翻译的不准确,将就点吧
*/

public classYellowHumanimplementsHuman {

public voidcry() {System.out.println("黄色人类会哭");

}

public voidlaugh() {System.out.println("黄色人类会大笑,幸福呀!");

}

public voidtalk() {System.out.println("黄色人类会说话,一般说的都是双字节");

}}

白色人类:

packagecom.cbf4life;

/**
* I'm glad to share my knowledge with you all.* 白色人类
*/

public classWhiteHumanimplementsHuman {

public voidcry() {System.out.println("白色人类会哭");

}

public voidlaugh() {System.out.println("白色人类会大笑,侵略的笑声");

}

public voidtalk() {System.out.println("白色人类会说话,一般都是但是单字节!");

}}

黑色人类:

packagecom.cbf4life;

/**
* I'm glad to share my knowledge with you all.
* 黑色人类,记得中学学英语,老师说black man是侮辱人的意思,不懂,没跟老外说话*/

public classBlackHumanimplementsHuman {public voidcry() {

System.out.println("黑人会哭");

public voidlaugh() {System.out.println("黑人会笑");

}
public voidtalk() {

System.out.println("黑人可以说话,一般人听不懂");}

}

}

人类也定义完毕了,那我们把八卦炉定义出来:

packagecom.cbf4life;importjava.util.List;

importjava.util.Random;

/**
* I'm glad to share my knowledge with you all.
* 今天讲女娲造人的故事,这个故事梗概是这样的:
*很久很久以前,盘古开辟了天地,用身躯造出日月星辰、山川草木,天地一片繁华
* One day,女娲下界走了一遭,哎!太寂寞,太孤独了,没个会笑的、会哭的、会说话的东东
*那怎么办呢?不用愁,女娲,神仙呀,造出来呀,然后捏泥巴,放八卦炉(后来这个成了太白金星的宝

贝)中烤,于是就有了人:
*我们把这个生产人的过程用Java程序表现出来:*/

public classHumanFactory{

//定一个烤箱,泥巴塞进去,人就出来,这个太先进了public static Human createHuman(Class c){

人类

Human human=null; //定义一个类型的人类try{

human=(Human)Class.forName(c.getName()).newInstance();//产生一个

} catch(InstantiationException e) {//你要是不说个人类颜色的话,没法烤,要白的黑,你说话了才好烤

System.out.println("必须指定人类的颜色");
} catch(IllegalAccessException e) {//定义的人类有问题,那就烤不出来了,这是...

System.out.println("人类定义错误!");
} catch(ClassNotFoundException e) {//你随便说个人类,我到哪里给你制造去?!

System.out.println("混蛋,你指定的人类找不到!");}

returnhuman;}

}

然后我们再把女娲声明出来:

packagecom.cbf4life;

/**
* @authorcbf4Life [e-mail]
* I'm glad to share my knowledge with you all.* 首先定义女娲,这真是额的神呀
*/

public classNvWa {
public static voidmain(String[] args) {

//女娲第一次造人,试验性质,少造点,火候不足,缺陷产品

System.out.println("------------造出的第一批人是这样的:白人-----------------");

Human whiteHuman = HumanFactory.createHuman(WhiteHuman.class);whiteHuman.cry();
whiteHuman.laugh();
whiteHuman.talk();

//女娲第二次造人,火候加足点,然后又出了个次品,黑人

System.out.println("\n\n------------造出的第二批人是这样的:黑人-----------------");

Human blackHuman = HumanFactory.createHuman(BlackHuman.class);blackHuman.cry();
blackHuman.laugh();
blackHuman.talk();

//第三批人了,这次火候掌握的正好,黄色人类(不写黄人,免得引起歧义),备注:RB人不属于此列

System.out.println("\n\n------------造出的第三批人是这样的:黄色人类-----------------");

Human yellowHuman = HumanFactory.createHuman(YellowHuman.class);yellowHuman.cry();
yellowHuman.laugh();
yellowHuman.talk()

}}

这样这个世界就热闹起来了,人也有了,但是这样创建太累了,神仙也会累的,那怎么办?神仙就想了:我塞进去一团泥巴,随机出来一群人,管他是黑人、白人、黄人,只要是人就成(你看看,神仙都偷懒,何况是我们人),先修改类图:

然后看我们的程序修改,先修改 HumanFactory.java,增加了 createHuman()方法:

packagecom.cbf4life;

importjava.util.List;importjava.util.Random;public classHumanFactory {

//定一个烤箱,泥巴塞进去,人就出来,这个太先进了public static Human createHuman(Class c){

Human human=null; //定义一个类型的人类

人类

try{
human=(Human)Class.forName(c.getName()).newInstance();//产生一个

} catch(InstantiationException e) {//你要是不说个人类颜色的话,没法烤,要白的黑,你说话了才好烤

System.out.println("必须指定人类的颜色");
} catch(IllegalAccessException e) {//定义的人类有问题,那就烤不出来了,这是...

System.out.println("人类定义错误!");
} catch(ClassNotFoundException e) {//你随便说个人类,我到哪里给你制造去?!

System.out.println("混蛋,你指定的人类找不到!");}

returnhuman;}

//女娲生气了,把一团泥巴塞到八卦炉,哎产生啥人类就啥人类public static Human createHuman(){

Human human=null;//定义一个类型的人类//首先是获得有多少个实现类,多少个人类

List<Class> concreteHumanList =ClassUtils.getAllClassByInterface(Human.class);//定义了多少人类

//八卦炉自己开始想烧出什么人就什么人
Random random =newRandom();
intrand = random.nextInt(concreteHumanList.size());

human = createHuman(concreteHumanList.get(rand));returnhuman;

}}

然后看女娲是如何做的:

packagecom.cbf4life;

/**

* I'm glad to share my knowledge with you all.* 首先定义女娲,这真是额的神呀
*/

第 25页

您的设计模式

public classNvWa {
public static voidmain(String[] args) {

//女娲第一次造人,试验性质,少造点,火候不足,缺陷产品

System.out.println("------------造出的第一批人是这样的:白人-----------------");

Human whiteHuman = HumanFactory.createHuman(WhiteHuman.class);whiteHuman.cry();
whiteHuman.laugh();
whiteHuman.talk();

//女娲第二次造人,火候加足点,然后又出了个次品,黑人

System.out.println("\n\n------------造出的第二批人是这样的:黑人-----------------");

Human blackHuman = HumanFactory.createHuman(BlackHuman.class);blackHuman.cry();
blackHuman.laugh();
blackHuman.talk();

//第三批人了,这次火候掌握的正好,黄色人类(不写黄人,免得引起歧义),备注:RB人不属于此列

System.out.println("\n\n------------造出的第三批人是这样的:黄色人类-----------------");

Human yellowHuman = HumanFactory.createHuman(YellowHuman.class);yellowHuman.cry();
yellowHuman.laugh();
yellowHuman.talk();

//女娲烦躁了,爱是啥人类就是啥人类,烧吧for(inti=0;i<10000000000;i++){

System.out.println("\n\n------------随机产生人类了-----------------"+

Human human = HumanFactory.createHuman();human.cry();
human.laugh();
human.talk();

}}

}

i);

哇,这个世界热闹了!,不过还没有完毕,这个程序你跑不起来,还要有这个类:

packagecom.cbf4life;

importjava.io.File;
importjava.io.IOException;importjava.net.URL;
importjava.util.ArrayList;importjava.util.Enumeration;importjava.util.List;

/**
 I'm glad to share my knowledge with you* all.
*
*/

@SuppressWarnings("all")public class ClassUtils{

//给一个接口,返回这个接口的所有实现类
public staticList<Class> getAllClassByInterface(Class c){

List<Class> returnClassList =newArrayList<Class>();//返回结果

//如果不是一个接口,则不做处理if(c.isInterface()){

String packageName = c.getPackage().getName();//获得当前的包名try{

及子包下的所有类

List<Class> allClass =getClasses(packageName);//获得当前包下以

//判断是否是同一个接口
for(inti=0;i<allClass.size();i++){

if(c.isAssignableFrom(allClass.get(i))){//判断是不是一个接口if(!c.equals(allClass.get(i))){//本身不加进去

              returnClassList.add(allClass.get(i));          }

}}

} catch(ClassNotFoundException e) {e.printStackTrace();

} catch(IOException e) {e.printStackTrace();

}

}

returnreturnClassList;}

//从一个包中查找出所有的类,在jar包中不能查找
private staticList<Class> getClasses(String packageName)

throwsClassNotFoundException, IOException {ClassLoader classLoader = Thread.currentThread()

.getContextClassLoader();
String path = packageName.replace('.','/');Enumeration<URL> resources = classLoader.getResources(path);List<File> dirs = newArrayList<File>();
while(resources.hasMoreElements()) {

          URL resource = resources.nextElement();

dirs.add(newFile(resource.getFile()));}

ArrayList<Class> classes =newArrayList<Class>();for(File directory : dirs) {

classes.addAll(findClasses(directory, packageName));}

returnclasses;}

private staticList<Class> findClasses(File directory, String packageName)throwsClassNotFoundException {

List<Class> classes =newArrayList<Class>();if(!directory.exists()) {

returnclasses;}

File[] files = directory.listFiles();for(File file : files) {

if(file.isDirectory()) {
assert!file.getName().contains(".");classes.addAll(findClasses(file, packageName + "."+

file.getName()));
} else if(file.getName().endsWith(".class")) {

classes.add(Class.forName(packageName + '.'+file.getName().substring(0, file.getName().length() - 6)));

}}

returnclasses;}

}

告诉你了,这个 ClassUtils 可是个宝,用处可大了去了,可以由一个接口查找到所有的实现类,也可以由父类查找到所有的子类,这个要自己修改一下,动脑筋想下,简单的很!完整的类图如下:

我们来总结一下,特别是增加了 createHuman()后,是不是这个工厂的扩展性更好了?你看你要再加一个人类,只要你继续集成 Human 接口成了,然后啥都不用修改就可以生产了,具体产多少,那要八卦炉说了算,简单工厂模式就是这么简单,那我们再引入一个问题:人是有性别的呀,有男有女,你这怎么没区别,别急,这个且听下回分解!

工厂方法模式还有一个非常重要的应用,就是延迟始化(Lazy initialization),什么是延迟始化呢?一个对象初始化完毕后就不释放,等到再次用到得就不用再次初始化了,直接从内存过中拿到就可以了,怎么实现呢,很简单,看例子:

packagecom.cbf4life.advance;

importjava.util.HashMap;

/**
* @authorcbf4Life [e-mail]
* I'm glad to share my knowledge with you all.*/

@SuppressWarnings("all")public class HumanFactory {

//定义一个MAP,初始化过的Human对象都放在这里第29页

您的设计模式

private staticHashMap<String,Human>humans=newHashMap<String,Human>();

//定一个烤箱,泥巴塞进去,人就出来,这个太先进了public static Human createHuman(Class c){

Human human=null;//定义一个类型的人类try{

//如果MAP中有,则直接从取出,不用初始化了

}
} catch(InstantiationException e) {//你要是不说个人类颜色的话,没法烤,要白的

黑,你说话了才好烤

System.out.println("必须指定人类的颜色");
} catch(IllegalAccessException e) {//一定定义的人类有问题,那就烤不出来了,

这是...

returnhuman;}

}

很简单,就加上了黄色那部分的代码,这个在类初始化很消耗资源的情况比较实用,比如你要连接硬件,或者是为了初始化一个类需要准备比较多条件(参数),通过这种方式可以很好的减少项目的复杂程度。

if(humans.containsKey(c.getSimpleName())){

human = humans.get(c.getSimpleName());

}else{

human = (Human)Class.forName(c.getName()).newInstance();

//放到MAP中

humans.put(c.getSimpleName(), human);

System.out.println("人类定义错误!");
} catch(ClassNotFoundException e) {//你随便说个人类,我到哪里给你制造去?!

System.out.println("混蛋,你指定的人类找不到!");}

 抽象工厂模式【Abstract Factory Pattern】

好了,我们继续上一节课,上一节讲到女娲造人,人是造出来了,世界时热闹了,可是低头一看,都是清一色的类型,缺少关爱、仇恨、喜怒哀乐等情绪,人类的生命太平淡了,女娲一想,猛然一拍脑袋,Shit!忘记给人类定义性别了,那怎么办?抹掉重来,然后就把人类重新洗牌,准备重新开始制造人类。

由于先前的工作已经花费了很大的精力做为铺垫,也不想从头开始了,那先说人类(Product 产品类)怎么改吧,好,有了,给每个人类都加一个性别,然后再重新制造,这个问题解决了,那八卦炉怎么办?只有一个呀,要么生产出全都是男性,要不都是女性,那不行呀,有了,把已经有了一条生产线——八卦炉(工厂模式中的 Concrete Factory)拆开,于是女娲就使用了“八卦拷贝术”,把原先的八卦炉一个变两个,并且略加修改,就成了女性八卦炉(只生产女性,一个具体工厂的实现类)和男性八卦炉(只生产男性,又一个具体工厂的实现类)

其中抽象工厂只实现了一个 createHuman 的方法,目的是简化实现类的代码工作量,这个在讲代码的时候会说。这里还使用了 Jdk 1.5 的一个新特性 Enum 类型,其实这个完全可以类的静态变量来实现,但我想既然是学习就应该学有所获得,即使你对这个模式非常了解,也可能没用过 Enum 类型,也算是一个不同的知识点吧,我希望给大家讲解,每次都有新的技术点提出来,每个人都会有一点的收获就足够了,然后在具体的项目中使用时,知道有这个技术点,然后上 baidu 狗狗一下就能解决问题。话题扯远了,我们继续类图,完整的类图如下,这个看不大清楚,其实就是上面那两个类图加起来,大家可以看源码中的那个类图文件:

  然后类图讲解完毕,我们来看程序实现:

packagecom.cbf4life;

/**
* I'm glad to share my knowledge with you all.
* 定义一个人类的统称,问题出来了,刚刚定义的时候忘记定义性别了*这个重要的问题非修改不可,否则这个世界上太多太多的东西不存在了*/

public interfaceHuman{//首先定义什么是人类

//人是愉快的,会笑的,本来是想用smile表示,想了一下laugh更合适,好长时间没有大笑了;public void laugh();

//人类还会哭,代表痛苦public void cry();

//人类会说话
public voidtalk();

//定义性别

public voidsex();}

人类的接口定义好,然后根据接口创建三个抽象类,也就是三个产品等级,实现 laugh()、cry()、talk()三个方法,以 AbstractYellowHuman 为例:

packagecom.cbf4life.yellowHuman;

importcom.cbf4life.Human;

/**
* I'm glad to share my knowledge with you all.* 为什么要修改成抽象类呢?要定义性别呀
*/

public abstract classAbstractYellowHumanimplementsHuman {

public voidcry() {System.out.println("黄色人类会哭");

}

public voidlaugh() {System.out.println("黄色人类会大笑,幸福呀!");

}

public voidtalk() {System.out.println("黄色人类会说话,一般说的都是双字节");

}

}

其他的两个抽象类 AbstractWhiteHuman 和 AbstractgBlackHuman 与此类似的事项方法,不再通篇拷贝代码,大家可以看一下源代码。算了,还是拷贝,反正是电子档的,不想看就往下翻页,也成就了部分“懒人”,不用启动 Eclipse,还要把源码拷贝进来:

白种人的抽象类:

packagecom.cbf4life.whiteHuman;

importcom.cbf4life.Human;

/**
* @authorcbf4Life [e-mail]
* I'm glad to share my knowledge with you all.* 白色人人类
*为了代码整洁,新建一个包,这里是白种人的天下了
*/

public abstract classAbstractWhiteHumanimplementsHuman {

public voidcry() {System.out.println("白色人类会哭");

}

public voidlaugh() {System.out.println("白色人类会大笑,侵略的笑声");

}

public voidtalk() {System.out.println("白色人类会说话,一般都是但是单字节!");

}}

黑种人的抽象类:

packagecom.cbf4life.blackHuman;

importcom.cbf4life.Human;

/**
* @authorcbf4Life [e-mail]
* I'm glad to share my knowledge with you all.
* 黑色人类,记得中学学英语,老师说black man是侮辱人的意思,不懂,没跟老外说话*/

public abstract classAbstractBlackHumanimplementsHuman {

public voidcry() {System.out.println("黑人会哭");

}

public voidlaugh() {System.out.println("黑人会笑");

}
public voidtalk() {

System.out.println("黑人可以说话,一般人听不懂");}

}

三个抽象类都实现完毕了,然后就是些实现类了。其实,你说抽象类放这里有什么意义吗?就是不允许你 new 出来一个抽象的对象呗,使用非抽象类完全就可以代替,呵呵,杀猪杀尾巴,各有各的杀法,不过既然进了 Java 这个门就要遵守 Java 这个规矩,我们看实现类:

女性黄种人的实现类:

packagecom.cbf4life.yellowHuman;

/**

* I'm glad to share my knowledge with you all.* 女性黄种人
*/

public classYellowFemaleHumanextendsAbstractYellowHuman {

public voidsex() {System.out.println("该黄种人的性别为女...");

}}

男性黄种人的实现类:

packagecom.cbf4life.yellowHuman;

/**

* I'm glad to share my knowledge with you all.* 男性黄种人
*/

public classYellowMaleHumanextendsAbstractYellowHuman {

public voidsex() {System.out.println("该黄种人的性别为男....");

}}

女性白种人的实现类:

packagecom.cbf4life.whiteHuman;

/**
* @authorcbf4Life [e-mail]
* I'm glad to share my knowledge with you all.\* 女性白种人
*/

public classWhiteFemaleHumanextendsAbstractWhiteHuman {public voidsex() {

System.out.println("该白种人的性别为女....");}

}

男性白种人的实现类:

packagecom.cbf4life.whiteHuman;

/**

* I'm glad to share my knowledge with you all.* 男性白种人
*/

public classWhiteMaleHumanextendsAbstractWhiteHuman {

public voidsex() {System.out.println("该白种人的性别为男....");

}}

女性黑种人的实现类:

packagecom.cbf4life.blackHuman;

/**
* @authorcbf4Life [e-mail]
* I'm glad to share my knowledge with you all.* 女性黑种人
*/

public classBlackFemaleHumanextendsAbstractBlackHuman {

public voidsex() {System.out.println("该黑种人的性别为女...");

}}

男性黑种人的实现类:

packagecom.cbf4life.blackHuman;

/**
* I'm glad to share my knowledge with you all.* 男性黑种人
*/

public classBlackMaleHumanextendsAbstractBlackHuman {

public voidsex() {System.out.println("该黑种人的性别为男...");

}}

抽象工厂模式下的产品等级和产品族都已经完成,也就是人类以及产生出的人类是什么样子的都已经定义好了,下一步就等着工厂开工创建了,那我们来看工厂类。

  在看工厂类之前我们先看那个枚举类型,这个是很有意思的:

packagecom.cbf4life;

/**
* I'm glad to share my knowledge with you all.* 世界上有哪些类型的人,列出来
* JDK 1.5开始引入enum类型也是目的的,吸引C程序员转过来*/

public enumHumanEnum{//把世界上所有人类型都定义出来

YelloMaleHuman("com.cbf4life.yellowHuman.YellowMaleHuman"),YelloFemaleHuman("com.cbf4life.yellowHuman.YellowFemaleHuman"),WhiteFemaleHuman("com.cbf4life.whiteHuman.WhiteFemaleHuman"),WhiteMaleHuman("com.cbf4life.whiteHuman.WhiteMaleHuman"),BlackFemaleHuman("com.cbf4life.blackHuman.BlackFemaleHuman"),BlackMaleHuman("com.cbf4life.blackHuman.BlackMaleHuman");

privateStringvalue="";//定义构造函数,目的是Data(value)类型的相匹配privateHumanEnum(String value){

this.value= value;}

publicString getValue(){return this.value;

}

/*
* java enum类型尽量简单使用,尽量不要使用多态、继承等方法

*毕竟用Clas完全可以代替enum*/

}

我之所以引入 Enum 这个类型,是想让大家在看这本书的时候能够随时随地的学到点什么,你如果看不懂设计模式,你可以从我的程序中学到一些新的技术点,不用像我以前报着砖头似的书在那里啃,看一遍不懂,再看第二遍,然后翻了英文原本才知道,哦~,原来是这样滴,只能说有些翻译家实在不懂技术。我在讲解技术的时候,尽量少用专业术语,尽量使用大部分人类都能理解的语言。

Enum 以前我也很少用,最近在一个项目中偶然使用上了,然后才发觉它的好处,Enum 类型作为一个参数传递到一个方法中时,在 Junit 进行单元测试的时候,不用判断输入参数是否为空、长度为 0 的边界异常条件,如果方法传入的参数不是 Enum 类型的话,根本就传递不进来,你说定义一个类,定义一堆的静态变量,这也可以呀,这个不和你抬杠,上面的代码我解释一下,构造函数没啥好说的,然后是 getValue()方法,就是获得枚举类型中一个元素的值,枚举类型中的元素也是有名称和值的,这个和 HashMap 有点类似。

  然后,我们看我们的工厂类,先看接口:

packagecom.cbf4life;

/**

* I'm glad to share my knowledge with you all.* 这次定一个接口,应该要造不同性别的人,需要不同的生产线*那这个八卦炉必须可以制造男人和女人

*/

public interfaceHumanFactory {//制造黄色人类

publicHuman createYellowHuman();//制造一个白色人类

publicHuman createWhiteHuman();

//制造一个黑色人类

publicHuman createBlackHuman();}

然后看抽象类:

packagecom.cbf4life.humanFactory;

importcom.cbf4life.Human;importcom.cbf4life.HumanEnum;importcom.cbf4life.HumanFactory;

/**

* I'm glad to share my knowledge with you all.* 编写一个抽象类,根据enum创建一个人类出来
*/

public abstract classAbstractHumanFactoryimplementsHumanFactory {/*

*给定一个性别人类,创建一个人类出来 专业术语是产生产品等级

*/

protectedHuman createHuman(HumanEnum humanEnum) {Human human =null;

//如果传递进来不是一个Enum中具体的一个Element的话,则不处理if(!humanEnum.getValue().equals("")) {

try{//直接产生一个实例human = (Human)

Class.forName(humanEnum.getValue()).newInstance();}catch(Exception e) {

//因为使用了enum,这个种异常情况不会产生了,除非你的enum有问题;

              e.printStackTrace();          }

}

returnhuman;}

}

看到没,这就是引入 enum 的好处,createHuman(HumanEnum humanEnum)这个方法定义了输入参数必须是 HumanEnum 类型,然后直接使用 humanEnum.getValue()方法就能获得具体传递进来的值,这个不多说了,大家自己看程序领会,没多大难度,这个抽象类的目的就是减少下边实现类的代码量,我们看实现类:

男性工厂,只创建男性:

packagecom.cbf4life.humanFactory;importcom.cbf4life.Human;

importcom.cbf4life.HumanEnum;

/**

* I'm glad to share my knowledge with you all.* 男性创建工厂
*/

public classMaleHumanFactoryextendsAbstractHumanFactory {

//创建一个男性黑种人
publicHuman createBlackHuman() {

return super.createHuman(HumanEnum.BlackMaleHuman);}

//创建一个男性白种人
publicHuman createWhiteHuman() {

return super.createHuman(HumanEnum.WhiteMaleHuman);}

//创建一个男性黄种人
publicHuman createYellowHuman() {

return super.createHuman(HumanEnum.YelloMaleHuman);}

}

女性工厂,只创建女性:

packagecom.cbf4life.humanFactory;importcom.cbf4life.Human;

importcom.cbf4life.HumanEnum;

/**
* @authorcbf4Life [e-mail]
* I'm glad to share my knowledge with you all.\* 女性创建工厂
*/

public classFemaleHumanFactoryextendsAbstractHumanFactory {

//创建一个女性黑种人
publicHuman createBlackHuman() {

return super.createHuman(HumanEnum.BlackFemaleHuman);}

//创建一个女性白种人
publiccreateWhiteHuman() {

}

//创建一个女性黄种人
publicHuman createYellowHuman() {

return super.createHuman(HumanEnum.YelloFemaleHuman);}

}

产品定义好了,工厂也定义好了,万事俱备只欠东风,那咱就开始造吧,哦,不对,女娲开始造人了:

packagecom.cbf4life;
importcom.cbf4life.humanFactory.FemaleHumanFactory;

importcom.cbf4life.humanFactory.MaleHumanFactory;

/**
* I'm glad to share my knowledge with you all.* 女娲建立起了两条生产线,分别是:
*男性生产线
*女性生产线
*/

Human

return super.createHuman(HumanEnum.WhiteFemaleHuman);

public classNvWa {
public static voidmain(String[] args) {

//第一条生产线,男性生产线
HumanFactory maleHumanFactory =newMaleHumanFactory();

//第二条生产线,女性生产线
HumanFactory femaleHumanFactory =newFemaleHumanFactory();

//生产线建立完毕,开始生产人了:
Human maleYellowHuman = maleHumanFactory.createYellowHuman();

Human femaleYellowHuman = femaleHumanFactory.createYellowHuman();

          maleYellowHuman.cry();          maleYellowHuman.laugh();          femaleYellowHuman.sex();          /*

* .....

*后面你可以续了

*/

}}

  两个八卦炉,一个造女的,一个造男的,开足马力,一直造到这个世界到现在这个模式为止。

抽象工厂模式讲完了,那我们再思考一些问题:工厂模式有哪些优缺点?先说优点,我这人一般先看人优点,非常重要的有点就是,工厂模式符合 OCP 原则,也就是开闭原则,怎么说呢,比如就性别的问题,这个世界上还存在双性人,是男也是女的人,那这个就是要在我们的产品族中增加一类产品,同时再增加一个工厂就可以解决这个问题,不需要我再来实现了吧,很简单的大家自己画下类图,然后实现下。

那还有没有其他好处呢?抽象工厂模式,还有一个非常大的有点,高内聚,低耦合,在一个较大的项目组,产品是由一批人定义开发的,但是提供其他成员访问的时候,只有工厂方法和产品的接口,也就是说只需要提供 Product Interface 和 Concrete Factory 就可以产生自己需要的对象和方法,Java 的高内聚低耦合的特性表现的一览无遗,哈哈。