【java设计模式】之 抽象工厂(Abstract Factory)模式-阿里云开发者社区

开发者社区> ghost丶桃子> 正文

【java设计模式】之 抽象工厂(Abstract Factory)模式

简介:
+关注继续查看

目录(?)[+]

1. 女娲的失误

        上一节学习了工厂模式,女娲运用了该模式成功创建了三个人种,可是问题来了,她发现没有性别……这失误也忒大了点吧……竟然没有性别,那岂不是……无奈,只好抹掉重来了,于是所有人都被消灭掉了,重新造人。

        女娲开始分析了,既然要区别男女,那么生产人种的工厂(八卦炉)要重新改造了,因为一个设备要么全男性,要么全女性。所以只能将八卦炉拆开了,把原先的一个变两个,并且略加修改,变成女性八卦炉和男性八卦炉,这样就可以了。于是女娲开始准备生产了,她先画了个示意图如下:

        这个图虽然有点大,但是不复杂,她将HumanFactory接口用两个新的接口继承,分别带有男性和女性特征;将原来具体的Human类也改成了抽象类,用两个具体的Human类去继承。下面我们看看女娲的实现:

        先看Human接口和它的几个抽象类:

[java] view plain copy
 在CODE上查看代码片派生到我的代码片
  1. //定义抽象人类接口  
  2. public interface Human {  
  3.     public void getColor();  
  4.     public void talk();  
  5.     public void getSex(); //多了个性别  
  6. }  
  7.   
  8. //定义抽象黄种人类  
  9. public abstract class AbstractYellowHuman implements Human {  
  10.     @Override  
  11.     public void getColor() {  
  12.         System.out.println("Yellow color");  
  13.     }  
  14.     @Override  
  15.     public void talk() {  
  16.         System.out.println("Yellow people");  
  17.     }   
  18. }   
  19. //抽象黑种人和白种人就不写了,跟抽象黄种人道理一样  
  20. //略  
  21.   
  22. //黄种人男性类  
  23. public class MaleYellowHuman extends AbstractYellowHuman {  
  24.     @Override  
  25.     public void getSex() {  
  26.         System.out.println("Yellow man!");  
  27.     }  
  28. }  
  29. //黄种人女性类略  
        以上省略了类似的代码,实现方式都一样,很简单,就不啰嗦了,到此为止,女娲把人种都定义好了,下面就是去定义八卦炉了:

[java] view plain copy
 在CODE上查看代码片派生到我的代码片
  1. //抽象工厂接口的定义  
  2. public interface HumanFactory {  
  3.     public Human createYellowHuman();  
  4.     public Human createBlackHuman();  
  5.     public Human createWhiteHuman();  
  6. }  
  7.   
  8. //生产女性的八卦炉  
  9. public class FemaleFactory implements HumanFactory {  
  10.     @Override  
  11.     public Human createYellowHuman() {  
  12.         return new FemaleBlackHuman();  
  13.     }  
  14.     @Override  
  15.     public Human createBlackHuman() {  
  16.         return new FemaleBlackHuman();  
  17.     }  
  18.     @Override  
  19.     public Human createWhiteHuman() {  
  20.         return new FemaleWhiteHuman();  
  21.     }  
  22. }  
  23.   
  24. //生产男性的八卦炉  
  25. public class MaleFactory implements HumanFactory {  
  26.     @Override  
  27.     public Human createYellowHuman() {  
  28.         return new MaleYellowHuman();  
  29.     }  
  30.     @Override  
  31.     public Human createBlackHuman() {  
  32.         return new MaleBlackHuman();  
  33.     }  
  34.     @Override  
  35.     public Human createWhiteHuman() {  
  36.         return new MaleWhiteHuman();  
  37.     }  
  38. }  
        好了,现在人种有了,八卦炉也有了,女娲终于可以再次造人了!

[java] view plain copy
 在CODE上查看代码片派生到我的代码片
  1. public class NvWa {  
  2.     public static void main(String[] args) {  
  3.         HumanFactory maleHumanFactory = new MaleFactory(); //第一条生产线:男性生产线  
  4.         HumanFactory femaleHumanFactory = new FemaleFactory(); //第二条生产线:女性生产线  
  5.           
  6.                 //生产线建立完毕,开始造人  
  7.         Human maleYellowHuman = maleHumanFactory.createYellowHuman(); //造黄色男性  
  8.         Human femaleYellowHuman = femaleHumanFactory.createYellowHuman(); //造黄色女性  
  9.           
  10.         System.out.println("--生产一个黄色女性--");  
  11.         femaleYellowHuman.getColor();  
  12.         femaleYellowHuman.talk();  
  13.         femaleYellowHuman.getSex();  
  14.           
  15.         System.out.println("--生产一个黄色男性--");  
  16.         maleYellowHuman.getColor();  
  17.         maleYellowHuman.talk();  
  18.         maleYellowHuman.getSex();  
  19.         /* 
  20.          * …… 
  21.          */  
  22.     }  
  23. }  
        到这里,抽象工厂模式的思路算是理清了,下面看看抽象工厂模式的定义。

2. 抽象工厂模式的定义

        抽象工厂模式(Abstract Factory Pattern)是一种比较常用的模式,其定义如下:

Provide an interface for creating families of related or dependent objects without specifying their concrete classes. 即为创建一组相关或相互依赖的对象提供一个接口,而且无须指定它们的具体类。它的通用类图如下:


        抽象工厂模式是工厂模式的升级版,在有多个业务品种、业务分类时,通过抽象工厂模式产生需要的对象是一种非常好的解决方式。我们来看看抽象工厂欧式的通用源代码,首先有两个互相影响的产品线(也叫产品族),例如汽车的左门和右门,这两个数量应该是相等的——两个对象之间的约束,每个型号的车门都是不一样的,这是产品等级结构约束的,我们先看看两个产品族的类图:


        注意类图上的圈圈、框框相对应,两个抽象的产品类可以有关系,例如共同继承或实现一个抽象类或接口,其源代码如下:

[java] view plain copy
 在CODE上查看代码片派生到我的代码片
  1. public abstract class AbstractProductA {  
  2.     //每个产品共有的方法  
  3.     public void shareMethod() {  
  4.       
  5.     }  
  6.     //每个产品相同的方法,不同的实现  
  7.     public abstract void doSomething();   
  8. }   
        两个具体的产品实现类的代码如下:

[java] view plain copy
 在CODE上查看代码片派生到我的代码片
  1. public class productA1 extends AbstractProductA {  
  2.     public abstract void doSomething(){  
  3.         System.out.println("产品A1的实现方法");  
  4.     }  
  5. }   
  6.   
  7. public class productA2 extends AbstractProductA {  
  8.     public abstract void doSomething(){  
  9.         System.out.println("产品A2的实现方法");  
  10.     }  
  11. }   

        产品B与此类似,不再赘述。抽象工厂类AbstractCreator的职责是定义每个工厂要实现的功能,在通用代码中,抽象工厂类定义了两个产品族的产品创建,如下:

[java] view plain copy
 在CODE上查看代码片派生到我的代码片
  1. public abstract class AbstractCreator {  
  2.     //创建A产品家族  
  3.     public abstract AbstracProductA createProductA();  
  4.     //创建B产品家族  
  5.     public abstract AbstracProductB createProductB();  
  6.     //如果有N个产品族,这里就应该有N个创建方法  
  7. }   
        如何创建一个产品呢?这是由具体的实现类来完成的,Creator1和Creator2代码如下:

[java] view plain copy
 在CODE上查看代码片派生到我的代码片
  1. public class Creator1 extends AbstractCreator {  
  2.     //只生产产品等级为1的A产品  
  3.     public AbstracProductA createProductA(){  
  4.         return new ProductA1();  
  5.     }  
  6.     //只生产产品等级为1的B产品  
  7.     public AbstracProductB createProductB() {  
  8.         return new ProductB1();  
  9.     }   
  10. }   
  11.   
  12. public class Creator2 extends AbstractCreator {  
  13.     //只生产产品等级为1的A产品  
  14.     public AbstracProductA createProductA(){  
  15.         return new ProductA2();  
  16.     }  
  17.     //只生产产品等级为1的B产品  
  18.     public AbstracProductB createProductB() {  
  19.         return new ProductB2();  
  20.     }   
  21. }   

       注:有M个产品等级就应该有M个实现工厂类,在每个实现工厂中,实现不同产品族的生产任务。

       在具体的业务中就可以生产一个与实现无关的对象了,如:

[java] view plain copy
 在CODE上查看代码片派生到我的代码片
  1. public class AbstractFactoryTest {  
  2.     public static void main(String[] args) {  
  3.         AbstractCreator creator1 = new Creator1();  
  4.         AbstractCreator creator2 = new Creator2();  
  5.         AbstractProductA a1 = creator1.createProductA();  
  6.         AbstractProductA a2 = creator2.createProductA();  
  7.   
  8.         AbstractProductB b1 = creator1.createProductB();  
  9.         AbstractProductB b2 = creator2.createProductB();  
  10.   
  11.         //……  
  12.     }  
  13. }  




3. 抽象工厂模式的优缺点

3.1 优点

        1)封装性。每个产品的实现类不是高层模块要关心的,它要关心的是接口,是抽象,它不关心对象是如何创建出来的,这都由工厂类负责的,只要知道工厂类是谁,我就能创建一个需要的对象,省时省力。

        2)产品族内的约束为非公开状态。例如生产男女比例的问题上,猜想女娲娘娘肯定有自己的打算,那么在抽象工厂模式中,这些约束都在工厂内里面实现的。

3.2 缺点

        抽象工厂模式最大的缺点就是产品族扩展非常困难。如果我们要增加一个产品C,也就是说产品族由原来的A和B增加到3个,那么我们首先要在抽象类AbstractCreator中增加createProductC()方法,然后两个实现类都要修改……说到这里,已经知道了扩展的弊端了……

        注意这里是产品族扩展比较困难,而不是产品等级扩展困难。产品等级扩展还是非常容易的,增加一个产品等级,只要增加一个工厂类负责新增加出来的产品生产任务即可。也就是说横向扩展容易,纵向扩展难。

        抽象工厂模式就介绍这么多,如有错误之处,欢迎留言指正~

       相关阅读:http://blog.csdn.net/column/details/des-pattern.html

_____________________________________________________________________________________________________________________________________________________

-----乐于分享,共同进步!

-----更多文章请看:http://blog.csdn.net/eson_15

版权声明:本文内容由阿里云实名注册用户自发贡献,版权归原作者所有,阿里云开发者社区不拥有其著作权,亦不承担相应法律责任。具体规则请查看《阿里云开发者社区用户服务协议》和《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容,填写侵权投诉表单进行举报,一经查实,本社区将立刻删除涉嫌侵权内容。

相关文章
C#简单工厂和抽象类的实例
using System; using System.Collections.Generic; using System.Diagnostics; using System.IO; using System.
727 0
Java描述设计模式(02):简单工厂模式
一、生活场景简介 1、引入场景 订餐流程简单描述 1)、食品抽象类,规定食品的基础属性操作 2)、鱼类,鸡肉类食品类扩展 3)、订餐流程类,根据食品名称,加工指定类型食品 4)、模拟客户端预定操作 2、源代码实现 1)、关系图谱 2)、代码实现 /** * 简单工厂模式引入场景 */ publ...
558 0
[软考考点解析]软件设计师--主存与Cache地址映射方式
1. 题目 主存与Cache的地址映射方式中,____方式可以实现任意主存的任意一块装入Cache中任意位置,只有装满才需要替换。 A 全相联 B 直接映射 C 组相联 D 串并联
8 0
反射与工厂设计模式 | 带你学《Java语言高级特性》之八十三
通过案例逐步掌握工厂设计模式,通过工厂类获取指定接口的实例化对象。
696 0
设计模式之四(抽象工厂模式第三回合)
原文:设计模式之四(抽象工厂模式第三回合) 前言 抽象工厂模式:提供一个创建一系列相关或相互依赖对象的接口,而无需指定它们具体的类。 抽象工厂模式最大的好处便是易于交换产品系列,由于具体工厂类,例如IFactory factory=new AccessFactory(),在一个应用中只需要在初始化的时候出现一次,这就使得改变一个应用的具体工厂变得非常容易,它只需要改变具体工厂即可使用不同的产品配置。
675 0
设计模式之四(抽象工厂模式第二回合)
原文:设计模式之四(抽象工厂模式第二回合) 前言 在第一回合中留下的问题,http://www.cnblogs.com/aehyok/archive/2013/05/19/3087497.html,现在就先处理一个简单的,只添加一个Department表。
722 0
设计模式快速学习(二)抽象工厂模式
抽象工厂模式(Abstract Factory Pattern)是围绕一个超级工厂创建其他工厂。该超级工厂又称为其他工厂的工厂。这种类型的设计模式属于创建型模式,它提供了一种创建对象的最佳方式。
788 0
1955
文章
0
问答
文章排行榜
最热
最新
相关电子书
更多
《2021云上架构与运维峰会演讲合集》
立即下载
《零基础CSS入门教程》
立即下载
《零基础HTML入门教程》
立即下载