引入
定义:
就是对一组具有相同主题的工厂进行封装(维基百科解释的很到位);
例如:生产一台PC机,使用工厂方法模式的话,一般会有cpu工厂,内存工厂,显卡工厂...但是使用抽象工厂模式的话,只有一个工厂就是PC工厂,但是一个PC工厂涵盖了cpu工厂,内存工厂,显卡工厂等要做的所有事;
举例:
上一节讲到女娲造人,人是造出来了,世界时热闹了,可是低头一看,都是清一色的类型,缺少关爱、仇恨、喜怒哀乐等情绪,人类的生命太平淡了,女娲一想,猛然一拍脑袋,Shit!忘记给人类定义性别了,那怎么办?抹掉重来,然后就把人类重新洗牌,准备重新开始制造人类。
由于先前的工作已经花费了很大的精力做为铺垫,也不想从头开始了,那先说人类(Product产品类)怎么改吧,好,有了,给每个人类都加一个性别,然后再重新制造,这个问题解决了,那八卦炉怎么办?只有一个呀,要么生产出全都是男性,要不都是女性,那不行呀,有了,把已经有了一条生产线——八卦
炉(工厂方法模式中的HumanFactory)拆开,于是女娲就使用了“八卦拷贝术”,把原先的八卦炉一个变两个,并且略加修改,就成了女性八卦炉(只生产女性,一个具体工厂的实现类)和男性八卦炉(只生产男性,又一个具体工厂的实现类),这个过程的类图如下:
先看人类(也就是产品)的类图:
这个类图也比较简单,Java 的典型类图,一个接口,几个抽象类,然后是几个实现类,没啥多说的,其中三个抽象类在抽象工厂模式中是叫做产品等级,六个实现类是叫做产品族,这个也比较好理解,实现类嘛是真实的产品,一个叫产品,多了就叫产品族,然后再看工厂类:
然后类图讲解完毕,我们来看程序实现:
package com.zpkj.project23;
public interface Human {
//首先定义什么是人类
//人是愉快的,会笑的,本来是想用smile表示,想了一下laugh更合适,好长时间没有大笑了;
public void laugh();
//人类还会哭,代表痛苦
public void cry();
//人类会说话
public void talk();
//定义性别
public void sex();
}
人类的接口定义好,然后根据接口创建三个抽象类,也就是三个产品等级,实现 laugh()、cry()、talk() 三个方法,以 AbstractYellowHuman 为例:
package com.zpkj.project23;
/**
* 黄色人种的抽象类
*/
public abstract class AbstractYellowHuman implements Human {
public void cry() {
System.out.println("黄色人种会哭");
}
public void laugh() {
System.out.println("黄色人种会大笑,幸福呀!");
}
public void talk() {
System.out.println("黄色人种会说话,一般说的都是双字节");
}
}
package com.zpkj.project23;
/**
* 黑人的抽象类
*/
public abstract class AbstractBlackHuman implements Human {
public void cry() {
System.out.println("黑人会哭");
}
public void laugh() {
System.out.println("黑人会笑");
}
public void talk() {
System.out.println("黑人可以说话,一般人听不懂");
}
}
package com.zpkj.project23;
/**
* 白人的抽象类
*/
public abstract class AbstractWhiteHuman implements Human {
public void cry() {
System.out.println("白色人种会哭");
}
public void laugh() {
System.out.println("白色人种会大笑,侵略的笑声");
}
public void talk() {
System.out.println("白色人种会说话,一般都是但是单字节!");
}
}
三个抽象类都实现完毕了,然后就是些实现类了。其实,你说抽象类放这里有什么意义吗?就是不允许你 new 出来一个抽象的对象呗,使用非抽象类完全就可以代替,呵呵,杀猪杀尾巴,各有各的杀法,不过既然进了 Java 这个门就要遵守 Java 这个规矩,我们看实现类:
package com.zpkj.project23;
/**
* 女性黄种人实现类
*/
public class YellowFemaleHuman extends AbstractYellowHuman {
public void sex() {
System.out.println("该黄种人的性别为女...");
}
}
package com.zpkj.project23;
/**
* 男性黄种人实现类
*/
public class YellowMaleHuman extends AbstractYellowHuman {
public void sex() {
System.out.println("该黄种人的性别为男....");
}
}
package com.zpkj.project23;
/**
* 白人男性实现类
*/
public class WhiteMaleHuman extends AbstractWhiteHuman {
public void sex() {
System.out.println("该白种人的性别为男....");
}
}
package com.zpkj.project23;
/**
* 白色女性的实现类
*/
public class WhiteFemaleHuman extends AbstractWhiteHuman {
public void sex() {
System.out.println("该白种人的性别为女....");
}
}
package com.zpkj.project23;
/**
* 黑人男性实现类
*/
public class BlackMaleHuman extends AbstractBlackHuman {
public void sex() {
System.out.println("该黑种人的性别为男...");
}
}
package com.zpkj.project23;
/**
* 黑人女性实现类
*/
public class BlackFemaleHuman extends AbstractBlackHuman {
public void sex() {
System.out.println("该黑种人的性别为女...");
}
}
抽象工厂模式下的产品等级和产品族都已经完成,也就是人类以及产生出的人类是什么样子的都已经定义好了,下一步就等着工厂开工创建了,那我们来看工厂类。在看工厂类之前我们先看那个枚举类型,这个是很有意思的:
package com.zpkj.project23;
public enum HumanEnum {
//把世界上所有人类型都定义出来
YelloMaleHuman("com.zpkj.project23.YellowMaleHuman"),
YelloFemaleHuman("com.zpkj.project23.YellowFemaleHuman"),
WhiteFemaleHuman("com.zpkj.project23.WhiteFemaleHuman"),
WhiteMaleHuman("com.zpkj.project23.WhiteMaleHuman"),
BlackFemaleHuman("com.zpkj.project23.BlackFemaleHuman"),
BlackMaleHuman("com.zpkj.project23.BlackMaleHuman");
private String value="";
private HumanEnum(String value){
this.value = value;
}
public String getValue(){
return this.value;
}
public HumanEnum getValue(String value){
for (HumanEnum e:HumanEnum.values()){
if(value.equals(e.getValue())){
return e;
}
}
return null;
}
}
然后,我们看我们的工厂类,先看接口:
package com.zpkj.project23;
public interface HumanFactory {
//制造黄色人种
public Human createYellowHuman();
//制造一个白色人种
public Human createWhiteHuman();
//制造一个黑色人种
public Human createBlackHuman();
}
然后看抽象类:
package com.zpkj.project23;
public abstract class AbstractHumanFactory implements HumanFactory {
protected Human 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();
}
}
return human;
}
}
男性工厂,只创建男性:
package com.zpkj.project23;
/**
* 男性工厂实现类
*/
public class MaleHumanFactory extends AbstractHumanFactory {
//创建一个男性黄种人
@Override
public Human createYellowHuman() {
return super.createHuman(HumanEnum.YelloMaleHuman);
}
//创建一个男性白种人
@Override
public Human createWhiteHuman() {
return super.createHuman(HumanEnum.WhiteMaleHuman);
}
//创建一个男性黑种人
@Override
public Human createBlackHuman() {
return super.createHuman(HumanEnum.BlackMaleHuman);
}
}
女性工厂,只创建女性:
package com.zpkj.project23;
/**
* 女性工厂实现类
*/
public class FemaleHumanFactory extends AbstractHumanFactory {
@Override
public Human createYellowHuman() {
return super.createHuman(HumanEnum.YelloFemaleHuman);
}
@Override
public Human createWhiteHuman() {
return super.createHuman(HumanEnum.WhiteFemaleHuman);
}
@Override
public Human createBlackHuman() {
return super.createHuman(HumanEnum.BlackFemaleHuman);
}
}
产品定义好了,工厂也定义好了,万事俱备只欠东风,那咱就开始造吧,哦,不对,女娲开始造人了:
package com.zpkj.project23;
public class NvWa {
public static void main(String[] args){
//男性工厂
MaleHumanFactory maleHumanFactory = new MaleHumanFactory();
//女性工厂
FemaleHumanFactory femaleHumanFactory = new FemaleHumanFactory();
Human yellowHuman = maleHumanFactory.createYellowHuman();
yellowHuman.sex();
yellowHuman.cry();
yellowHuman.laugh();
Human whiteHuman = femaleHumanFactory.createWhiteHuman();
whiteHuman.sex();
whiteHuman.laugh();
whiteHuman.cry();
}
}
总结:
抽象工厂很重要的优点就是符合OCP原则,也就是开闭原则,比如我们要再要增加一类双性人!既是男人也是女人,我们只需要在产品族中增加一类产品,同时再增加一个工厂就可以解决。
抽象工厂模式,还有一个非常大的有点,高内聚,低耦合,在一个较大的项目组,产品是由一批人定义开发的,但是提供其他成员访问的时候,只有工厂方法和产品的接口,也就是说只需要提供 Product Interface 和Concrete Factory 就可以产生自己需要的对象和方法,Java 的高内聚低耦合的特性表现的一览无遗
引用:
本文原书:
《您的设计模式》 作者:CBF4LIFE