`
zhongzhihua
  • 浏览: 313197 次
  • 来自: ...
社区版块
存档分类
最新评论

设计模式之Abstract Factory　- 抽象工厂模式

设计模式JavaScriptUMLDAO数据结构 
阅读更多

Abstract Factory模式也叫抽象工厂模式，是由GoF提出的23种设计模式中的一种。它是对象创建型模式之一，通过抽象工厂为客户（调用者）生成多类产品，抽象工厂负责管理子工厂对象，子工厂负责生成某一类具体的产品对象。 本文介绍设计模式中的抽象工厂（Abstract Factory）模式的概念，用法，以及实际应用中怎么样使用Factory Method模式进行开发。

Abstract Factory模式的概念

在大规模的系统开发过程中，考虑系统的灵活性，低耦合性，可扩展性等因素，常常不直接使用new来生成类的实例，而是通过一个叫做工厂（Factory）的类来专门生成类的实例。
我们在
设计模式之Factory Method　- 工厂方法模式
一文中讨论了Factory Method模式，这里再讨论一下一种更高层次的工厂模式：Abstract Factory模式。

Factory Method模式的主要特点是通过工厂提供的方法生成类的对象，而具体的对象的生成工作被委让给（延迟到）子工厂，所以被称为工厂方法模式。
Abstract Factory模式与Factory Method很相似，都是通过工厂的方法生成目标类的对象，但它们之间的也存在一些区别。

Abstract Factory模式与Factory Method模式的主要区别：

- Factory Method采用的是工厂类继承机制（生成子工厂类，重载该工厂方法，在重载的方法中生成目标对象）。而Abstract Factory强调的是对象组合机制，由在父工厂内定义不同的“子工厂”对象来负责不同的目标对象的创建。再深入一点理解：
- Factory Method模式中，产品（目标对象）的使用者可能需要使用具体的子工厂来生成该产品；Abstract Factory模式则采用传参数的形式直接在父工厂内决定该产品对象应该由哪一个子工厂生产。也就是说，Abstract Factory模式中，跟客户打交道的只有抽象工厂与抽象产品，客户不需要知道产品由哪个工厂生产，也不需要知道被生产的是哪一种具体的产品。
- Factory Method模式中，省城的对象产品只限定于某一类产品；Abstract Factory模式则可以提供多个生产接口生成多类产品
- Abstract Factory模式Factory Method模式的更高层次的抽象，也更最具一般性。可以把Factory Method模式看作是Abstract Factory模式的一种特殊情况

简单一点说，Abstract Factory模式通过抽象工厂为客户（调用者）生成多类产品，抽象工厂负责管理子工厂对象，子工厂负责生成某一类具体的产品对象。

Abstract Factory模式的应用场景：

- 存在多类产品，并需要对这些产品区别对待处理：需要分别为这些产品定义2个以上的接口或抽象类
- 客户端只需要与最上层的工厂（抽象工厂），与最上层的抽象产品打交道

Abstract Factory用到以下几个概念：
- 抽象工厂类（1个）：定义创建不同类实例的多个接口；创建与管理子工厂对象，提供统一方法以取得不同的子工厂对象
- 子工厂类（多个）：生成具体的类的实例
- 抽象产品类（多个）：对产品的抽象
- 具有继承关系的具体的产品类（多个）：继承自抽象产品类，它们之间一般存在或多或少的依耐关系

工厂与产品的关系可以用UML类图表示：


下面举例说明。

Abstract Factory模式的实现范例


有一类Bus（公交车）系列产品Bus，ModelBus；
与另一类Truck（卡车）系列产品Truck，ModelTruck；

其中Bus与Truck可以由同一个工厂BusTruckFactory生产；ModelBus与ModelTruck可以由同一个工厂ModelFactory生产。
BusTruckFactory工厂与ModelFactory工厂由总工厂CarFactory统一管理。
我们（客户）直接从CarFactory工厂定购Bus系列产品，与Truck（卡车）系列产品。

下面我们用Abstract Factory模式实现上面的过程

CarFactory：定义生产Bus和Truck的接口规范；管理BusTruckFactory与ModelFactory工厂。
BusTruckFactory：生产Bus和Truck的非模型车。
ModelFactory：生产Bus和Truck的模型车。

AbstractBus：公交车（包括模型与非模型车）父类
Bus：公交车。继承自AbstractBus类。
ModelBus：公交车模型。继承自AbstractBus类。

AbstractTruck：卡车（包括模型与非模型车）父类
Truck：卡车。继承自AbstractTruck类。
ModelTruck：卡车模型。继承自AbstractTruck类。

工厂类定义：
总工厂CarFactory.java

<script src="http://www.lifevv.com/images/code/js/shCore.js" type="text/javascript"></script><script> &lt;!--// function _syboos_pmplat_setUpCode() { //dp.SyntaxHighlighter.ClipboardSwf = 'js/clipboard.swf'; dp.SyntaxHighlighter.HighlightAll('_syboos_pmplat_code'); } window.onload=_syboos_pmplat_setUpCode; //--&gt; </script><script src="http://www.lifevv.com/images/code/js/shBrushJava.js" type="text/javascript"></script>
view plain print ?
  1. public   abstract   class  CarFactory {  
  2.     public   static   final   int  BUS_TRUCK =  1 ;    //参数定义。生产非模型车。   
  3.     public   static   final   int  BUS_TRUCK_MODEL =  2 ;  //参数定义。生产模型车。   
  4.       
  5.   
  6.     //定义生产公交车的接口   
  7.     public   abstract  AbstractBus createBus();  
  8.     //定义生产卡车的接口   
  9.     public   abstract  AbstractTruck createTruck();  
  10.   
  11.     //管理子工厂类，根据参数调用不同的子工厂进行生产   
  12.     public   static  CarFactory getCarFactory( int  carType) {  
  13.         switch  (carType) {  
  14.             case  BUS_TRUCK:  
  15.                 return   new  BusTruckFactory();  
  16.             case  BUS_TRUCK_MODEL:  
  17.                 return   new  ModelFactory();  
  18.             default :  
  19.                 return   null ;  
  20.         }  
  21.     }  
  22. }   
public abstract class CarFactory {
    public static final int BUS_TRUCK = 1;   //参数定义。生产非模型车。
    public static final int BUS_TRUCK_MODEL = 2; //参数定义。生产模型车。
    

    //定义生产公交车的接口
    public abstract AbstractBus createBus();
    //定义生产卡车的接口
    public abstract AbstractTruck createTruck();

    //管理子工厂类，根据参数调用不同的子工厂进行生产
    public static CarFactory getCarFactory(int carType) {
        switch (carType) {
            case BUS_TRUCK:
                return new BusTruckFactory();
            case BUS_TRUCK_MODEL:
                return new ModelFactory();
            default:
                return null;
        }
    }
}



生产非模型车的工厂BusTruckFactory.java

view plain print ?
  1. public   class  BusTruckFactory  extends  CarFactory {  
  2.     //生产公交车（非模型）   
  3.     public  AbstractBus createBus() {  
  4.         return   new  Bus();  
  5.     }  
  6.     //生产卡车（非模型）   
  7.     public  AbstractTruck createTruck() {  
  8.         return   new  Truck();  
  9.     }  
  10. }   
public class BusTruckFactory extends CarFactory {
    //生产公交车（非模型）
    public AbstractBus createBus() {
        return new Bus();
    }
    //生产卡车（非模型）
    public AbstractTruck createTruck() {
        return new Truck();
    }
}



生产模型车的工厂ModelFactory.java

view plain print ?
  1. public   class  ModelFactory  extends  CarFactory {  
  2.     //生产公交车模型   
  3.     public  AbstractBus createBus() {  
  4.         return   new  ModelBus();  
  5.     }  
  6.     //生产卡车模型   
  7.     public  AbstractTruck createTruck() {  
  8.         return   new  ModelTruck();  
  9.     }  
  10. }   
public class ModelFactory extends CarFactory {
    //生产公交车模型
    public AbstractBus createBus() {
        return new ModelBus();
    }
    //生产卡车模型
    public AbstractTruck createTruck() {
        return new ModelTruck();
    }
}




产品类定义：
Bus系列产品：

view plain print ?
  1. public   class  AbstractBus {  
  2.     public  String getType() {  
  3.         return   "Abstract Bus" ;  
  4.     }  
  5. }  
  6.   
  7.   
  8. public   class  Bus  extends  AbstractBus {  
  9.     public  String getType() {  
  10.         return   "Bus" ;  
  11.     }  
  12. }  
  13.   
  14. public   class  ModelBus  extends  AbstractBus {  
  15.     public  String getType() {  
  16.         return   "ModelBus" ;  
  17.     }  
  18. }   
public class AbstractBus {
    public String getType() {
        return "Abstract Bus";
    }
}


public class Bus extends AbstractBus {
    public String getType() {
        return "Bus";
    }
}

public class ModelBus extends AbstractBus {
    public String getType() {
        return "ModelBus";
    }
}



Truck系列产品：

view plain print ?
  1. public   class  AbstractTruck {  
  2.     public  String getType() {  
  3.         return   "Abstract Truck" ;  
  4.     }  
  5. }  
  6.   
  7.   
  8. public   class  Truck  extends  AbstractTruck {  
  9.     public  String getType() {  
  10.         return   "Truck" ;  
  11.     }  
  12. }  
  13.   
  14. public   class  ModelTruck  extends  AbstractTruck {  
  15.     public  String getType() {  
  16.         return   "ModelTruck" ;  
  17.     }  
  18. }   
public class AbstractTruck {
    public String getType() {
        return "Abstract Truck";
    }
}


public class Truck extends AbstractTruck {
    public String getType() {
        return "Truck";
    }
}

public class ModelTruck extends AbstractTruck {
    public String getType() {
        return "ModelTruck";
    }
}



Client调用：

view plain print ?
  1. public   class  Client {  
  2.     public   static   void  main(String[] args) {  
  3.     //取得工厂对象   
  4.         CarFactory factory = CarFactory.getCarFactory(CarFactory.BUS_TRUCK);  
  5.         //生产公交车   
  6.         Bus bus = factory.createBus();  
  7.         System.out.println("生产了："  + bus.getType());  
  8.         //生产卡车   
  9.         Truck truck = factory.createTruck();  
  10.         System.out.println("生产了："  + truck.getType());  
  11.   
  12.     //取得工厂对象   
  13.         factory = CarFactory.getCarFactory(CarFactory.BUS_TRUCK_MODEL);  
  14.         //生产公交车   
  15.         bus = factory.createBus();  
  16.         System.out.println("生产了："  + bus.getType());  
  17.         //生产卡车   
  18.         truck = factory.createTruck();  
  19.         System.out.println("生产了："  + truck.getType());  
  20.   }  
  21. }   
public class Client {
    public static void main(String[] args) {
    //取得工厂对象
        CarFactory factory = CarFactory.getCarFactory(CarFactory.BUS_TRUCK);
        //生产公交车
        Bus bus = factory.createBus();
        System.out.println("生产了：" + bus.getType());
        //生产卡车
        Truck truck = factory.createTruck();
        System.out.println("生产了：" + truck.getType());

    //取得工厂对象
        factory = CarFactory.getCarFactory(CarFactory.BUS_TRUCK_MODEL);
        //生产公交车
        bus = factory.createBus();
        System.out.println("生产了：" + bus.getType());
        //生产卡车
        truck = factory.createTruck();
        System.out.println("生产了：" + truck.getType());
  }
}



执行Client，输出结果：

C:\AbstractFactory>javac *.java
C:\AbstractFactory>java Client
生产了：Bus
生产了：Truck
生产了：ModelBus
生产了：ModelTruck
C:\FactoryMethod>

 

小结

本文比较详细地介绍了Abstract Factory模式的概念，并应用具体的范例让我们更进一步地加深了对Abstract Factory模式的了解。

Abstract Factory模式的应用范围很广，近期我们会使用Abstract Factory模式实现支持多数据库的DAO体系结构

分享到：
| 分析模式---建模原则
评论
发表评论

您还没有登录,请您登录后再发表评论

相关推荐

    设计模式---抽象工厂模式（Abstract Factory）-UML图 (StarUML)

    设计模式---抽象工厂模式（Abstract Factory）-UML图 (StarUML)

    设计模式之-抽象工厂-AbstractFactory

    抽象工厂（Abstract Factory）设计模式是软件工程中一种重要的创建型设计模式，它提供了一种创建对象组的方式，这些对象属于同一族系并且彼此相关。这个模式的主要目标是定义一个接口，用于创建一族相关或相互依赖的...

    创建型设计模式----抽象工厂模式

    抽象工厂模式是创建型设计模式的一种，它提供了一种创建对象族（一组具有相互依赖关系的对象）的方法，而无需指定具体类。这种模式的核心在于它允许客户端代码与具体实现细节解耦，使得更换一个产品族变得更为容易。...

    设计模式----抽象工厂模式

    抽象工厂模式是设计模式中的一种创建型模式，它提供了一种创建对象族的接口，而无需指定具体的类。这种模式允许客户端使用一个通用接口来创建一组相关或相互依赖的对象，而无需了解它们的具体实现。在Java或其他面向...

    创建型-抽象工厂模式（Abstract Factory）

    此外，抽象工厂模式还可以与其他设计模式结合使用，比如工厂方法模式（Factory Method Pattern），在某些情况下，可以将抽象工厂模式的抽象工厂类设计为工厂方法模式，让子类决定实例化哪一个类。同时，抽象工厂模式...

    设计模式 - 抽象工厂模式

    设计模式 - 抽象工厂模式 抽象工厂模式是一种创建型设计模式，它提供了一种方式来创建一组相关或相互依赖的对象，而不需要指定具体的类。该模式允许客户端使用抽象的接口来创建一组相关的产品，而不需要关系实际...

    走进设计模式之抽象工厂(Abstract Factory)

    总之，"走进设计模式之抽象工厂"这篇博客深入探讨了抽象工厂模式的原理、实现方式、应用场景及其优缺点，旨在帮助读者理解并有效地运用这一设计模式。通过阅读博客和分析提供的代码示例，开发者可以更好地掌握抽象...

    设计模式-抽象工厂模式（讲解及其实现代码）

    抽象工厂模式是设计模式中的一种创建型模式，它提供了一种创建对象集合的接口，而无需指定具体的类。这种模式允许系统独立于如何创建、组合和表示产品对象的细节进行设计，为产品族（一组相关或相互依赖的对象）提供...

    设计模式C++学习之抽象工厂模式（AbstractFactory）

    抽象工厂模式是设计模式中的一种结构型模式，它在C++编程中有着广泛的应用。这个模式主要用于创建一系列相关的对象，而无需指定它们的具体类。在本文中，我们将深入探讨抽象工厂模式的概念、工作原理以及在C++中的...

    设计模式-抽象工厂模式

    抽象工厂模式是设计模式中的一种创建型模式，它提供了一种创建对象族的接口，而无需指定其具体的类。这种模式的关键在于“族”，即一系列相关的对象。在抽象工厂模式中，我们创建一个抽象工厂接口，然后为每一种具体...

    java常用设计模式-抽象工厂模式

    抽象工厂模式（Abstract Factory Pattern）是一种创建型设计模式，它通过定义一个创建对象的接口来创建对象，但将具体实现的决定留给子类来决定。在抽象工厂模式中，接口是负责创建一个相关对象的工厂，不需要显式...

    java设计模式-抽象工厂模式

    抽象工厂模式是设计模式中的一种，它属于创建型模式，主要解决的是当系统有多个产品族，而每个产品族又有多个具体产品时，如何组织代码的问题。在Java中，抽象工厂模式提供了一种创建对象组的方式，使得这些对象属于...

    设计模式-抽象工厂-Java 源码

    抽象工厂模式是设计模式中的一种创建型模式，它提供了一个创建对象族的接口，而具体的对象族由子类决定。这种模式允许系统在不指定具体产品的前提下，能够创建一系列相关或相互依赖的对象，同时避免了硬编码所造成的...

    Java常用设计模式(SingleTon、FactoryMethod、AbstractFactory)

    Java设计模式是面向对象编程...在阅读《Chapter1___Java常用设计模式(SingleTon、FactoryMethod、AbstractFactory)》的相关资料时，你可以更深入地学习这些模式的细节，包括适用场景、优缺点以及如何在实际项目中实现。

    设计模式--抽象工厂

    "抽象工厂"是设计模式中的一种，属于创建型模式，它提供了一种创建对象族的接口，而无需指定它们的具体类。这个模式的核心在于隔离了产品对象的创建过程，使得系统对具体产品的依赖最小化，从而增强了系统的灵活性和...

    设计模式-抽象工厂模式javademo

    抽象工厂模式是软件设计模式中的一种创建型模式，它提供了一种创建对象族（一组具有相互依赖关系的对象）的方法，而无需指定它们的具体类。在Java编程中，抽象工厂模式通常用于实现跨平台或者跨框架的接口，使得系统...

    李建忠 C#面向对象设计模式纵横谈(3)：Abstract Factory 抽象工厂模式(创建型模式)

    **抽象工厂模式（Abstract Factory Pattern）是创建型设计模式之一，它提供了一种创建对象的接口，使得子类可以决定实例化哪一个类。这种类型的设计模式属于类的创建模式。** 在C#中，抽象工厂模式的核心在于抽象...

    创建型模式之抽象工厂模式(Abstract Factory Pattern)

    抽象工厂模式是设计模式中的一种创建型模式，其主要目的是为了解耦客户端代码与具体产品的实现。在软件工程中，当系统需要根据不同的平台、环境或者配置产生一系列相关对象，而这些对象之间的关系又非常复杂时，抽象...

    设计模式举例-抽象工厂模式（有图有真相）

    抽象工厂模式是设计模式中的一种创建型模式，它提供了一种创建对象集合的接口，而无需指定具体类。这种模式的关键在于，它允许客户端代码在不关心具体实现的情况下，能够创建一系列相关的对象，同时保持了良好的封装...

    设计模式--抽象工厂之小解

    **设计模式——抽象工厂之小解** 在软件工程中，设计模式是一种被广泛采用的解决常见问题的经验总结，它们是经过验证的、可重用的解决方案。抽象工厂（Abstract Factory）设计模式是其中的一种创建型模式，它提供了...

Magicbox
Global site tag (gtag.js) - Google Analytics