Java设计模式——工厂设计模式

转载 2016年08月30日 15:14:19
工厂模式:主要用来实例化有共同接口的类,工厂模式可以动态决定应该实例化那一个类。
工厂模式的形态
工厂模式主要用一下几种形态:
1:简单工厂(Simple Factory)。
2:工厂方法(Factory Method)。
3:抽象工厂(Abstract Factory)。

简单工厂(Simple Factory)
又叫静态工厂,是工厂模式三中状态中结构最为简单的。主要有一个静态方法,用来接受参数,并根据参数来决定返回实现同一接口的不同类的实例。我们来看一个具体的例子:
假设一家工厂,几生产洗衣机,有生产冰箱,还有空调等等..
我们先为所有产品定义一个共同的产品接口
  1. public interface Product{} 

接着我们让这个工厂的所有产品都必须实现此接口
  1. public class Washer implements Product{ 
  2.    public Washer(){ 
  3.        System.out.println("洗衣机被制造了"); 
  4.    } 
  5.  
  6. public class Icebox implements Product{ 
  7.    public Icebox(){ 
  8.        System.out.println("冰箱被制造了"); 
  9.    } 
  10.  
  11. public class AirCondition implements Product{ 
  12.    public Icebox(){ 
  13.        System.out.println("空调被制造了"); 
  14.    } 

接下来我们来写一个工厂类,有它来负责生产以上的产品
  1. public class SimpleFactory { 
  2.      
  3.     public static Product factory(String productName) throws Exception{ 
  4.         if(productName.equals("Washer")){ 
  5.             return new Washer(); 
  6.         }else if(productName.equals("Icebox")){ 
  7.             return new Icebox(); 
  8.         }else if(productName.equals("AirCondition")){ 
  9.             return new AirCondition(); 
  10.         }else
  11.             throw new Exception("没有该产品"); 
  12.         } 
  13.     } 

好了,有了这个工厂类,我们就可以开始下定单了,SimpleFactory将根据不同的定单类决定生产什么产品。
  1. public static void main(String[] args) { 
  2.     try { 
  3.               SimpleFactory.factory("Washer"); 
  4.               SimpleFactory.factory("Icebox"); 
  5.               SimpleFactory.factory("AirCondition"); 
  6.             } catch (Exception e) { 
  7.         e.printStackTrace(); 
  8.     } 

由上面的代码可以看出,简单工厂的核心就是一个SimpleFactory类,他拥有必要的逻辑判断能力和所有产品的创建权利,我们只需要向把定单给他,就能得到我们想要的产品。这使用起来似乎非常方便。
但,实际上,这个SimpleFactory有很多的局限。首先,我们每次想要增加一种新产品的时候,都必须修改SimpleFactory的原代码。其次,当我们拥有很多很多产品的时候,而且产品之间又存在复杂的层次关系的时候,这个类必须拥有复杂的逻辑判断能力,其代码量也将不断地激增,这对以后的维护简直就是恐怖两个字...
还有就是,整个系统都严重依赖SimpleFactory类,只要SimpleFactory类一出问题,系统就进入不能工作的状态,这也是最为致命的一点....
以上的不足将在工厂模式的另外两种状态中得到解决。

工厂方法(Factory Method)
上面的代码告诉我们,简单工厂并不简单,它是整个模式的核心,一旦他出了问题,整个模式都将受影响而不能工作,为了降低风险和为日后的维护、扩展做准备,我们需要对它进行重构,引入工厂方法
工厂方法为工厂类定义了接口,用多态来削弱了工厂类的职能,以下是工厂接口的定义:
  1. public interface Factory{ 
  2.   public Product create(); 

我们再来定义一个产品接口
  1. public interface Product{} 

一下是实现了产品接口的产品类
  1. public class Washer implements Product{ 
  2.    public Washer(){ 
  3.        System.out.println("洗衣机被制造了"); 
  4.    } 
  5.  
  6. public class Icebox implements Product{ 
  7.    public Icebox(){ 
  8.        System.out.println("冰箱被制造了"); 
  9.    } 
  10.  
  11. public class AirCondition implements Product{ 
  12.    public Icebox(){ 
  13.        System.out.println("空调被制造了"); 
  14.    } 

接下来,就是工厂方法的核心部分,也就是具体创建产品对象的具体工厂类,
  1. //创建洗衣机的工厂 
  2. public class CreateWasher implements Factory{ 
  3.     public Product create(){ 
  4.           return new Washer(); 
  5.     } 
  6.  
  7. //创建冰箱的工厂 
  8. public class CreateIcebox implements Factory{ 
  9.     public Product create(){ 
  10.           return new Icebox(); 
  11.     } 
  12.  
  13. //创建空调的工厂 
  14. public class CreateAirCondition implements Factory{ 
  15.     public Product create(){ 
  16.           return new AirCondition(); 
  17.     } 

从上面创建产品对象的代码可以看出,工厂方法简单工厂的主要区别是,简单工厂是把创建产品的职能都放在一个类里面,而工厂方法则把不同的产品放在实现了工厂接口的不同工厂类里面,这样就算其中一个工厂类出了问题,其他工厂类也能正常工作,互相不受影响,以后增加新产品,也只需要新增一个实现工厂接口工厂类,就能达到,不用修改已有的代码。但工厂方法也有他局限的地方,那就是当面对的产品有复杂的等级结构的时候,例如,工厂除了生产家电外产品,还生产手机产品,这样一来家电是手机就是两大产品家族了,这两大家族下面包含了数量众多的产品,每个产品又有多个型号,这样就形成了一个复杂的产品树了。如果用工厂方法来设计这个产品家族系统,就必须为每个型号的产品创建一个对应的工厂类,当有数百种甚至上千种产品的时候,也必须要有对应的上百成千个工厂类,这就出现了传说的类爆炸,对于以后的维护来说,简直就是一场灾难.....

抽象工厂(Factory Method)
抽象工厂:意的意图在于创建一系列互相关联或互相依赖的对象。<<Java设计模式>>
我自己觉得抽象工厂是在工厂方法的基础上引进了分类管理的概念....
工厂方法用来创建一个产品,它没有分类的概念,而抽象工厂则用于创建一系列产品,所以产品分类成了抽象工厂的重点,
我们继续用上面的例子来说明:
工厂生产的所有产品都用都用大写字母来标明它们的型号,比如冰箱,就有“冰箱-A",“冰箱-B",同样,其他的产品也都是遵守这个编号规则,于是就有了一下产品家族树

冰箱:

  1.   
  2. 冰箱-A  
  3. 冰箱-B


洗衣机:

  1.   
  2. 洗衣机-A  
  3. 洗衣机-B

我们可以为冰箱和洗衣机分别定义两个产品接口,以对他们进行分类,
  1. //洗衣机接口 
  2. public interface Washer{ 
  3.  
  4. //冰箱接口 
  5. public interface Icebox{ 

接着,我们分别创建这两个接口的具体产品
  1. //洗衣机-A 
  2. public class WasherA implements Washer{ 
  3.    public WasherA(){ 
  4.        System.out.println("洗衣机-A被制造了"); 
  5.    } 
  6.  
  7. //洗衣机-B 
  8. public class WasherB implements Washer{ 
  9.    public WasherB(){ 
  10.        System.out.println("洗衣机-B被制造了"); 
  11.    } 
  12.  
  13. //冰箱-A 
  14. public class IceboxA implements Icebox{ 
  15.    public IceboxA(){ 
  16.        System.out.println("冰箱-A被制造了"); 
  17.    } 
  18.  
  19. //冰箱-B 
  20. public class IceboxB implements Icebox{ 
  21.    public IceboxB(){ 
  22.        System.out.println("冰箱-B被制造了"); 
  23.    } 

到此,产品部分我们准备好了,接下来我们来处理工厂部分,我们先来定义工厂行为接口
  1. public interface Factory{ 
  2.        public Washer createWasher(); 
  3.        public Icebox createIcebox(); 

接下来我创造具体的工厂类,我们根据上面产品的接口,把型号A的产品分为一类,由一个工厂来管理,把型号为B的产品有另一个工厂管理,根据这个分类,我们可以实现如下的两个具体工厂类
  1. //创建型号为A的产品工厂 
  2. public class FactoryA implements Factory{ 
  3.        //创建洗衣机-A 
  4.        public Washer createWasher(){ 
  5.             return new WasherA(); 
  6.        } 
  7.  
  8.        //创建冰箱-A 
  9.        public Icebox createIcebox(){ 
  10.             return new IceboxA(); 
  11.        } 
  12.  
  13. //创建型号为B的产品工厂 
  14. public class FactoryB implements Factory{ 
  15.        //创建洗衣机-B 
  16.        public Washer createWasher(){ 
  17.             return new WasherB(); 
  18.        } 
  19.  
  20.        //创建冰箱-B 
  21.        public Icebox createIcebox(){ 
  22.             return new IceboxB(); 
  23.        } 


这样,我们的抽象工厂就完成了。有上面可以看出,在运用上我觉得工厂方法和抽象工厂,都有自己的应用场景,并没有什么优劣之分,但在应用抽象工厂之前,要先对创建的对象进行系统的分类,这点很重要,好的产品分类规则能为具体工厂类的选择调用和以后的扩展提供清晰的思路.

简单工厂设计模式的好处

简单工厂:单独的,创建对象,返回对象。 在一个方法中创建好对象,调用此方法即根据传入参数可获得到不同需求的对象,我曾纳闷为什么要单独创建对象,为什么不直接new对象使用? 唉,好处就在这儿,咋想想...
  • Java_Dmz
  • Java_Dmz
  • 2017年09月02日 13:58
  • 219

浅谈java中dao工厂设计模式

      来源:http://www.114java.com/javajichu/201007/2389.html     在JAVA开发中,随 着软件分层设计的流行及广泛的应用,对于DAO设 ...
  • heqiyu34
  • heqiyu34
  • 2011年02月17日 15:25
  • 5266

设计模式【工厂方法模式】

本文主要是分享自己在学习设计模式过程中的心得与记录,有什么不当之处,望各位有心关注的看官,给予指证与说明。本文主要讲述【工厂方法模式】,望各位细细品读。【转载使用,请注明出处:http://blog....
  • ma_hoking
  • ma_hoking
  • 2014年09月23日 22:34
  • 1221

23种设计模式—之简单工厂模式

简单工厂模式(SimpleFactory Pattern):又称为静态工厂方法(Static Factory Method)模式,它属于类创建型模式。在简单工厂模式中,可以根据参数的不同返回不同类的实...
  • JavaWebRookie
  • JavaWebRookie
  • 2015年11月06日 13:46
  • 2261

大话设计模式—工厂模式

一、简介工厂模式主要是为创建对象提供了接口。工厂模式按照《Java与模式》中的提法分为三类: 简单工厂模式(Simple Factory) 工厂方法模式(Factory Method) 抽象工厂模...
  • lmb55
  • lmb55
  • 2015年05月31日 14:42
  • 1141

java设计模式学习笔记--可配置的简单工厂模式

提出问题试想在简单工厂模式中如果添加实现类到现有的系统中,那么就需要修该工厂类,因为修改方式很简单,在这里就不举例了。如果每次都这样做,也太那个啥了。。。解决问题在这里有一种解决方案就是使用配置文件,...
  • E_xiake
  • E_xiake
  • 2015年09月09日 21:03
  • 337

使用工厂设计模式的场景

使用工厂设计模式的场景 博客分类:  设计模式 使用工厂设计模式的场景  创建类对象虽然可以使用new(底层也是通过反射创建对象的),但是在一些情况下使用工厂模式确实最合适的。  情况一:如果...
  • zhangziwen94nb
  • zhangziwen94nb
  • 2015年03月04日 17:16
  • 4662

PHP设计模式系列(四):工厂方法模式

工厂方法模式工厂方法模式(Factory Method Pattern)又称为工厂模式,也叫虚拟构造器(Virtual Constructor)模式或者多态工厂(Polymorphic Factory...
  • qq_32300363
  • qq_32300363
  • 2017年04月29日 14:42
  • 479

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

1.工厂模式的定义         工厂模式使用的频率非常高,我们在开发中总能见到它们的身影。其定义为:Define an interface for creating an object, but ...
  • eson_15
  • eson_15
  • 2016年04月23日 10:48
  • 14939

设计模式适用场景整理

整理一下适用场景,便于遇到合适场景时通过使用设计模式更好地去掌握设计模式设计模式分创建型、行为型、结构型创建型策略模式:某一个功能有多种方案可以选择的情景 单例模式:创建独一无二的,只能有一个实例的...
  • qq_34244317
  • qq_34244317
  • 2017年09月03日 00:28
  • 350
内容举报
返回顶部
收藏助手
不良信息举报
您举报文章:Java设计模式——工厂设计模式
举报原因:
原因补充:

(最多只允许输入30个字)