简单工厂、工厂方法、抽象工厂之小结与区别

设计模式：简单工厂、工厂方法、抽象工厂之小结与区别

分类： 设计/UML/MDA 2009-08-14 12:56 2962人阅读 评论(5) 收藏 举报

简单工厂，工厂方法，抽象工厂都属于设计模式中的创建型模式。其主要功能都是帮助我们把对象的实例化部分抽取了出来，优化了系统的架构，并且增强了系统的扩展性。

本文是本人对这三种模式学习后的一个小结以及对他们之间的区别的理解。

简单工厂

简单工厂模式的工厂类一般是使用静态方法，通过接收的参数的不同来返回不同的对象实例。

不修改代码的话，是无法扩展的。

简单工厂需要的 1、一个产品接口、和实现产品接口的产品类   2、创建产品类的工厂类（创建产品的业务逻辑在工厂类中完成）

工厂方法

工厂方法是针对每一种产品提供一个工厂类。通过不同的工厂实例来创建不同的产品实例。

在同一等级结构中，支持增加任意产品。

工厂方法模式：   1、产品接口，实现产品接口的产品类   2、工厂方法接口，接口有一个方法   3、针对每一种产品都要有一个对应的工厂类，不同的工厂实例创建不同的产品实例。

抽象工厂

抽象工厂是应对产品族概念的。比如说，每个汽车公司可能要同时生产轿车，货车，客车，那么每一个工厂都要有创建轿车，货车和客车的方法。

应对产品族概念而生，增加新的产品线很容易，但是无法增加新的产品。

抽象工厂模式                 1、产品接口、实现产品接口的产品类             2、抽象工厂接口、接口中有多个方法创建多个产品线

1、产品接口、实现产品接口的产品类

2、抽象工厂接口、接口中有多个方法创建多个产品线

小结

★工厂模式中，重要的是工厂类，而不是产品类。产品类可以是多种形式，多层继承或者是单个类都是可以的。但要明确的，工厂模式的接口只会返回一种类型的实例，这是在设计产品类的时候需要注意的，最好是有父类或者共同实现的接口。

★使用工厂模式，返回的实例一定是工厂创建的，而不是从其他对象中获取的。

★工厂模式返回的实例可以不是新创建的，返回由工厂创建好的实例也是可以的。

区别

简单工厂 ： 用来生产同一等级结构中的任意产品。（对于增加新的产品，无能为力）

工厂方法 ：用来生产同一等级结构中的固定产品。（支持增加任意产品）

抽象工厂 ：用来生产不同产品族的全部产品。（对于增加新的产品，无能为力；支持增加产品族）

以上三种工厂 方法在等级结构和产品族这两个方向上的支持程度不同。所以要根据情况考虑应该使用哪种方法。

最近这三个模式有点搞混了，而且网上也有类似情况。总结一下。

简单工厂：严格说并不是一个设计模式。简单工厂没有抽象类，只有一个具体工厂类如MyFactory，然后MyFactory里面有个工厂方法CreateProduct返回一个基类产品，具体返回什么具体实例通过传入参数然后用case判断。

用手机生产做个例子：

比如Nokia简单工厂就是只有NokiaFactory工厂类，工厂方法就是CreateNokiaPhone，参数是Nokia手机型号，根据不同型号创建不同的Nokia手机（使用case）。很明显的缺点就是Nokia每发明一个新型号的手机都需要修改简单工厂类（增加case判断），违反了封闭修改，开放扩展原则。

工厂方法：该模式有一个抽象基类和若干个派生的具体工厂类，基类定义了一个虚工厂方法返回指定产品类的基类，派生类需要实现该虚方法并创建具体产品类返回。注意工厂方法的每个具体工厂只负责返回一种产品类。

同样以手机生产做例子：

Nokia工厂方法模式有一个工厂基类NokiaFactory，注意此工厂和上面不一样，是抽象的。该类定义一个虚工厂方法CreateNokiaPhone，该方法返回NokiaPhone基类。然后不同型号的手机对应一个该型号的手机工厂，比如N97Factory，注意此工厂派生于NokiaFactory基类，N97Factory实现虚工厂方法，它返回值是具体的Nokia手机类，如new N97Phone。（注意N97Phone是NokiaPhone的派生类）这样的优点就是，新出一个Nokia手机型号，只需派生一个该型号的工厂而无需修改原来的代码。符合封闭修改，开放扩展原则。

抽象工厂：该模式和工厂方法模式很相似，也是一个抽象基类和若干个具体工厂类，不同的是抽象工厂的工厂基类定义了多个虚工厂方法，每个虚工厂方法负责返回一种产品，多个工厂方法返回多种产品，并且这些产品具有某些联系。

抽象工厂就不止生产Nokia手机了，还生产相关的周边产品，首先NokiaFactory基类会定义两个虚方法，一个是CreateNokiaPhone用来生产手机，另一个是CreateNokiaCharger用于生产对应型号的手机充电器（假定不同型号手机使用不同的充电器）。然后派生类N97Factory就要生产两种相关的产品，一个是N97Phone,还有一个是N97Charger，这两个对象是对应的关系，因此封装到抽象工厂来生产一系列相关的对象。

总结：用最简单的话来概括就是，简单工厂只有一个具体工厂类来创建一种基类的多个不同派生类，工厂方法就是有多个派生于一个基类的具体工厂类，每个具体工厂只生产一种基类的一个派生类，抽象工厂也是只有一个工厂基类，但是每个具体工厂生产多个相关基类的各一个派生类。

Factory   Method是一种创建性模式,它定义了一个创建对象的接口,但是却让子类来决定具体实例化哪一个类.当一个类无法预料要创建哪种类的对象或是一个类需要由子类来指定创建的对象时我们就需要用到Factory   Method   模式了.简单说来,Factory   Method可以根据不同的条件产生不同的实例,当然这些不同的实例通常是属于相同的类型,具有共同的父类.Factory   Method把创建这些实例的具体过程封装起来了,简化了客户端的应用,也改善了程序的扩展性,使得将来可以做最小的改动就可以加入新的待创建的类.   通常我们将Factory   Method作为一种标准的创建对象的方法,当发现需要更多的灵活性的时候,就开始考虑向其它创建型模式转化

工 厂模式，也叫做说虚构造器，在简单工厂中间插入了一个具体产品工厂，这个工厂知道产品构造时候的具体细节，而简单工厂模式的产品具体构造细节是在一个个 if/else分支，或者在switch/case分支里面的。工厂模式的好处就在于将工厂和产品之间的耦合降低，将具体产品的构造过程放在了具体工厂类 里面。在以后扩展产品的时候方便很多，只需要添加一个工厂类，一个产品类，就能方便的添加产品，而不需要修改原有的代码。而在简单工厂中，如果要增加一个 产品，则需要修改工厂类，增加if/else分支，或者增加一个case分支，工厂模式符合软件开发中的OCP原则（open close principle），对扩展开放，对修改关闭。

principle  [ˈprinsəpl]

工厂模式，实际上就是隐藏了实现的细节，用户不用关心对象是怎么创建出来的。

轉貼:

设计模式之Factory——买货篇

今天老婆让我去市场买一些水果，具体买什么自己定（哈，老婆放放权了！）。来到市场，我发现主要有一些水果：苹果（Apple），葡萄（Grape）和鸭梨（Pear）。

到底买什么好呢？我一阵思量。俗话说：“饭后一只烟，赛过活神仙。饭后吃苹果，西施见我躲。”为了老婆的漂亮，我决定买苹果。

好，言归正传，开始买吧！

主要有以下三种Factory模式：

Simple   Factory模式

专门定义一个类来负责创建其它类的实例，被创建的实例通常都具有共同的父类。

Factory   Method模式

将对象的创建交由父类中定义的一个标准方法来完成，而不是其构造函数，究竟应该创建何种对象由具体的子类负责决定。

Abstract   Factory模式

提供一个共同的接口来创建相互关联的多个对象。

一、Simple   Factory模式：

1、     在这里，我们先定义水果（Fruit）接口：

public   interface   Fruit   {

void   plant();     //水果是被种植的

void   enableEat();     //水果能吃

}

2、     苹果（Apple）是对水果（Fruit）接口的实现：

public   class   Apple   implements   Fruit{

public   void   plant(){

System.out.println("种苹果!");

}

public   void   enableEat(){

System.out.println("苹果好吃!");

}

}

3、     葡萄（Grape）是对水果（Fruit）接口的实现：

public   class   Grape   implements   Fruit{

public   void   plant(){

System.out.println("种葡萄!");

}

public   void   enableEat(){

System.out.println("葡萄好吃!");

}

}

4、     鸭梨（Pear）是对水果（Fruit）接口的实现：

public   class   Pear   implements   Fruit{

public   void   plant(){

System.out.println("种鸭梨!");

}

public   void   enableEat(){

System.out.println("鸭梨好吃!");

}

}

5、定义买水果（BuyFruit）这一过程类：

public   class   BuyFruit   {

public   static   Fruit   buyFruit(String   which){

if   (which.equalsIgnoreCase("apple"))   {     //如果是苹果，则返回苹果实例

return   new   Apple();

}

else   if   (which.equalsIgnoreCase("pear")){     //如果是鸭梨，则返回鸭梨实例

return   new   Strawberry();

}

else   if   (which.equalsIgnoreCase("grape"))   {   //如果是葡萄，则返回葡萄实例

return   new   Grape();

}

else{

return   null;

}

}

}

6、     编写测试类：

public   class   FruitTest   {

public   static   void     main(String   args[]){

BuyFruit   buy   =   new   BuyFruit();       //开始买水果这个过程

buy.buyFruit("apple").enableEat();   //调用苹果的enableEat()方法

}

}

7、     说明：

A：我要购买苹果，只需向工厂角色（BuyFruit）请求即可。而工厂角色在接到请求后，会自行判断创建和提供哪一个产品。

B：但是对于工厂角色（BuyFruit）来说，增加新的产品（比如说增加草莓）就是一个痛苦的过程。工厂角色必须知道每一种产品，如何创建它们，以及何时向客户端提供它们。换言之，接纳新的产品意味着修改这个工厂。

C：因此Simple   Factory模式的开放性比较差。

有什么办法可以解决这个问题吗？那就需要Factory   Method模式来为我们服务了。

二、Factory   Method模式：

1、同样，我们先定义水果（Fruit）接口：

public   interface   Fruit   {

void   plant();     //水果是被种植的

void   enableEat();     //水果能吃

}

2、苹果（Apple）是对水果（Fruit）接口的实现：

public   class   Apple   implements   Fruit{

public   void   plant(){

System.out.println("种苹果!");

}

public   void   enableEat(){

System.out.println("苹果好吃!");

}

}

3、葡萄（Grape）是对水果（Fruit）接口的实现：

public   class   Grape   implements   Fruit{

public   void   plant(){

System.out.println("种葡萄!");

}

public   void   enableEat(){

System.out.println("葡萄好吃!");

}

}

4、鸭梨（Pear）是对水果（Fruit）接口的实现：

public   class   Pear   implements   Fruit{

public   void   plant(){

System.out.println("种鸭梨!");

}

public   void   enableEat(){

System.out.println("鸭梨好吃!");

}

}

5、在这里我们将买水果（BuyFruit）定义为接口类：

public   interface   BuyFruit{

public   Fruit   buyFruit();       //定义买水果这一过程

}

6、买苹果是（BuyApple）对买水果（BuyFruit）这个接口的实现

public   class   BuyApple   implements   BuyFruit{

public   Fruit   buyFruit(){

return   new   Apple();     //返回苹果实例

}

}

7、买鸭梨是（BuyPear）对买水果（BuyFruit）这个接口的实现

public   class   BuyPear   implements   BuyFruit{

public   Fruit   BuyPear   (){

return   new   Pear();     //返回鸭梨实例

}

}

8、买葡萄是（BuyGrape）对买水果（BuyFruit）这个接口的实现

public   class   BuyGrape   implements   BuyFruit{

public   Fruit   BuyGrape   (){

return   new   Grape   ();     //返回葡萄实例

}

}

9、编写测试类：

public   class   FruitTest   {

public   static   void     main(String   args[]){

BuyApple   buy   =   new   BuyApple();   //开始买水果这个过程

buy.buyFruit().enableEat();             //调用苹果的enableEat()方法

}

}

10、说明：

A：工厂方法模式和简单工厂模式在结构上的不同是很明显的。工厂方法模式的核心是一个抽象工厂类，而简单工厂模式把核心放在一个具体类上。工厂方法模式可 以允许很多具体工厂类从抽象工厂类中将创建行为继承下来，从而可以成为多个简单工厂模式的综合，进而推广了简单工厂模式。

B：工厂方法模式退化后可以变得很像简单工厂模式。设想如果非常确定一个系统只需要一个具体工厂类，那么就不妨把抽象工厂类合并到具体的工厂类中去。由于 反正只有一个具体工厂类，所以不妨将工厂方法改成为静态方法，这时候就得到了简单工厂模式。C：如果需要加入一个新的水果，那么只需要加入一个新的水果类 以及它所对应的工厂类。没有必要修改客户端，也没有必要修改抽象工厂角色或者其他已有的具体工厂角色。对于增加新的水果类而言，这个系统完全支持“开-闭 ”原则。

D：对Factory   Method模式而言，它只是针对一种类别（如本例中的水果类Fruit），但如果我们还想买肉，那就不行了，这是就必须要Factory   Method模式帮忙了。

三、Abstract   Factory模式

1、同样，我们先定义水果（Fruit）接口：

public   interface   Fruit   {

void   plant();     //水果是被种植的

void   enableEat();     //水果能吃

}

2、苹果（Apple）是对水果（Fruit）接口的实现：

public   class   Apple   implements   Fruit{

public   void   plant(){

System.out.println("种苹果!");

}

public   void   enableEat(){

System.out.println("苹果好吃!");

}

}

3、葡萄（Grape）是对水果（Fruit）接口的实现：

public   class   Grape   implements   Fruit{

public   void   plant(){

System.out.println("种葡萄!");

}

public   void   enableEat(){

System.out.println("葡萄好吃!");

}

}

4、鸭梨（Pear）是对水果（Fruit）接口的实现：

public   class   Pear   implements   Fruit{

public   void   plant(){

System.out.println("种鸭梨!");

}

public   void   enableEat(){

System.out.println("鸭梨好吃!");

}

}

5、     定义肉（Meat）接口：

public   interface   Meat   {

void   feed();     //肉是喂养的

void   enableEat();     //肉能吃

}

6、     猪肉（BigMeat）是对肉（Meat）接口的实现：

public   class   BigMeat   implements   Meat{

public   void   feed(){

System.out.println("养猪!");

}

public   void   enableEat(){

System.out.println("猪肉好吃!");

}

}

7、     牛肉（CowMeat）是对肉（Meat）接口的实现：

public   class   CowMeat   implements   Meat   {

public   void   feed(){

System.out.println("养牛!");

}

public   void   enableEat(){

System.out.println("牛肉好吃!");

}

}

8、     我们可以定义买货人（Buyer）接口：

public   interface   Buyer   {

public   Fruit   buyFruit(Fruit   whichFruit);

public   Meat   buyMeat(Meat   whichMeat);

}

9、     我（MyBuyer）是对买货人（Buyer）接口的实现：

public   class   MyBuyer   implements   Buyer{

public   Fruit   buyFruit(Fruit   whichFruit){

return   whichFruit;

}

public   Meat   buyMeat(Meat   whichMeat){

return   whichMeat;

}

}

10、编写测试类：

public   class   MyBuyerAbstractTest   {

public   static   void     main(String   args[]){

Fruit   apple   =   new   Apple();       //苹果实例

Meat   big   =   new   BigMeat();     //猪肉实例

MyBuyer   my   =   new   MyBuyer();     //我是买者的实例

my.buyFruit(apple).enableEat();     //我买苹果

my.buyMeat(big).enableEat();         //我买猪肉

}

}

11、说明：

A：抽象工厂模式可以向客户端提供一个接口，使得客户端在不必指定产品的具体类型的情况下，创建多个产品族中的产品对象。这就是抽象工厂模式的用意。

B：抽象工厂模式是所有形态的工厂模式中最为抽象和最具一般性的一种形态。

C：抽象工厂模式与工厂方法模式的最大区别就在于，工厂方法模式针对的是一个产品（Fruit）等级结构；而抽象工厂模式则需要面对多个产品等级结构(Fruit、Meat)。