抽象工厂模式

最新推荐文章于 2024-04-17 13:59:01 发布
最新推荐文章于 2024-04-17 13:59:01 发布
阅读量654 收藏
点赞数
分类专栏： 设计模式

一、 抽象工厂（Abstract Factory）模式

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

为了方便引进抽象工厂模式，引进一个新概念：产品族（Product Family）。所谓产品族，是指位于不同产品等级结构，功能相关联的产品组成的家族。如图：

 

图中一共有四个产品族，分布于三个不同的产品等级结构中。只要指明一个产品所处的产品族以及它所属的等级结构，就可以唯一的确定这个产品。

引进抽象工厂模式

所谓的抽象工厂是指一个工厂等级结构可以创建出分属于不同产品等级结构的一个产品族中的所有对象。如果用图来描述的话，如下图：

 

二、 Abstract Factory模式的结构：

 


图中描述的东西用产品族描述如下：

 


抽象工厂（Abstract Factory）角色：担任这个角色的是工厂方法模式的核心，它是与应用系统商业逻辑无关的。

具体工厂（Concrete Factory）角色：这个角色直接在客户端的调用下创建产品的实例。这个角色含有选择合适的产品对象的逻辑，而这个逻辑是与应用系统的商业逻辑紧密相关的。

抽象产品（Abstract Product）角色：担任这个角色的类是工厂方法模式所创建的对象的父类，或它们共同拥有的接口。

具体产品（Concrete Product）角色：抽象工厂模式所创建的任何产品对象都是某一个具体产品类的实例。这是客户端最终需要的东西，其内部一定充满了应用系统的商业逻辑。



三、 程序举例：

该程序演示了抽象工厂的结构，本身不具有任何实际价值。

//  Abstract Factory pattern -- Structural example  
using  System;
//  "AbstractFactory"
abstract   class  AbstractFactory
{
  // Methods
  abstract public AbstractProductA CreateProductA();
  abstract public AbstractProductB CreateProductB();
}
  // Methods
  abstract public AbstractProductA CreateProductA();
  
  abstract public AbstractProductB CreateProductB();
}
}
//  "ConcreteFactory1"
class  ConcreteFactory1 : AbstractFactory
{
  // Methods
  override public AbstractProductA CreateProductA()
  {
    return new ProductA1();
  }
  override public AbstractProductB CreateProductB()
  {
    return new ProductB1();
  }
}
  // Methods
  override public AbstractProductA CreateProductA()
  
  {
    return new ProductA1();
  }
    return new ProductA1();
  }
  }
  override public AbstractProductB CreateProductB()
  
  {
    return new ProductB1();
  }
    return new ProductB1();
  }
  }
}
//  "ConcreteFactory2"
class  ConcreteFactory2 : AbstractFactory
{
  // Methods
  override public AbstractProductA CreateProductA()
  {
    return new ProductA2();
  }

  override public AbstractProductB CreateProductB()
  {
    return new ProductB2();
  }
}
  // Methods
  override public AbstractProductA CreateProductA()
  
  {
    return new ProductA2();
  }
    return new ProductA2();
  }
  }
  override public AbstractProductB CreateProductB()
  
  {
    return new ProductB2();
  }
    return new ProductB2();
  }
  }
}
//  "AbstractProductA"
abstract   class  AbstractProductA
{
}
}
//  "AbstractProductB"
abstract   class  AbstractProductB
{
  // Methods
  abstract public void Interact( AbstractProductA a );
}
  // Methods
  abstract public void Interact( AbstractProductA a );
}
}
//  "ProductA1"
class  ProductA1 : AbstractProductA
{
}
}
//  "ProductB1"
class  ProductB1 : AbstractProductB
{
  // Methods
  override public void Interact( AbstractProductA a )
  {
    Console.WriteLine( this + " interacts with " + a );
  }
}
  // Methods
  override public void Interact( AbstractProductA a )
  
  {
    Console.WriteLine( this + " interacts with " + a );
  }
    Console.WriteLine( this + " interacts with " + a );
  }
  }
}
//  "ProductA2"
class  ProductA2 : AbstractProductA
{
}
}
//  "ProductB2"
class  ProductB2 : AbstractProductB
{
  // Methods
  override public void Interact( AbstractProductA a )
  {
    Console.WriteLine( this + " interacts with " + a );
  }
}
  // Methods
  override public void Interact( AbstractProductA a )
  
  {
    Console.WriteLine( this + " interacts with " + a );
  }
    Console.WriteLine( this + " interacts with " + a );
  }
  }
}
//  "Client" - the interaction environment of the products
class  Environment
{
  // Fields
  private AbstractProductA AbstractProductA;
  private AbstractProductB AbstractProductB;

  // Constructors
  public Environment( AbstractFactory factory )
  {
    AbstractProductB = factory.CreateProductB();
    AbstractProductA = factory.CreateProductA();
  }
 
  // Methods
  public void Run()
  {
    AbstractProductB.Interact( AbstractProductA );
  }
}
  // Fields
  private AbstractProductA AbstractProductA;
  
  private AbstractProductB AbstractProductB;

  
  // Constructors
  public Environment( AbstractFactory factory )
  
  {
    AbstractProductB = factory.CreateProductB();
    AbstractProductA = factory.CreateProductA();
  }
    AbstractProductB = factory.CreateProductB();
    AbstractProductA 
    AbstractProductA = factory.CreateProductA();
  }
  }
 
  // Methods
  public void Run()
  
  {
    AbstractProductB.Interact( AbstractProductA );
  }
    AbstractProductB.Interact( AbstractProductA );
  }
}
/// <summary>
/// ClientApp test environment
/// </summary>
/// ClientApp test environment
/// </summary>
class  ClientApp
{
  public static void Main(string[] args)
  {
    AbstractFactory factory1 = new ConcreteFactory1();
    Environment e1 = new Environment( factory1 );
    e1.Run();

    AbstractFactory factory2 = new ConcreteFactory2();
    Environment e2 = new Environment( factory2 );
    e2.Run();
  }
}
  public static void Main(string[] args)
  
  {
    AbstractFactory factory1 = new ConcreteFactory1();
    Environment e1 = new Environment( factory1 );
    e1.Run();

    AbstractFactory factory2 = new ConcreteFactory2();
    Environment e2 = new Environment( factory2 );
    e2.Run();
  }
    AbstractFactory factory1 = new ConcreteFactory1();
    Environment e1 
    Environment e1 = new Environment( factory1 );
    e1.Run();

    AbstractFactory factory2 
    e1.Run();
    AbstractFactory factory2 = new ConcreteFactory2();
    Environment e2 
    Environment e2 = new Environment( factory2 );
    e2.Run();
  }
    e2.Run();
  }
}

 


四、 在什么情形下使用抽象工厂模式：

在以下情况下应当考虑使用抽象工厂模式：

    • 一个系统不应当依赖于产品类实例如何被创建、组合和表达的细节，这对于所有形态的工厂模式都是重要的。 
    • 这个系统有多于一个的产品族，而系统只消费其中某一产品族。 
    • 同属于同一个产品族的产品是在一起使用的，这一约束必须在系统的设计中体现出来。 
    • 系统提供一个产品类的库，所有的产品以同样的接口出现，从而使客户端不依赖于实现。

五、 抽象工厂的起源

据说最早的应用是用来创建在不同操作系统的视窗环境下都能够运行的系统。比如在Windows与Unix系统下都有视窗环境的构件，在每一个操作系统中，都有一个视窗构件组成的构件家族。我们可以通过一个抽象角色给出功能描述，而由具体子类给出不同操作系统下的具体实现，如图：

 

可以发现上面产品类图有两个产品等级结构，分别是Button与Text；同时有两个产品族：Unix产品族与Windows产品族。

 

系统对产品对象的创建要求由一个工厂的等级结构满足。其中有两个具体工厂角色，即UnixFactory和WinFactory。UnixFactory对象负责创建Unix产品族中的产品，而WinFactory负责创建Windows产品族中的产品。

 

显然一个系统只能够在某一个操作系统的视窗环境下运行，而不能同时在不同的操作系统上运行。所以，系统实际上只能消费属于同一个产品族的产品。

在现代的应用中，抽象工厂模式的使用范围已经大大扩大了，不再要求系统只能消费某一个产品族了。



六、 Abstract Factory模式在实际系统中的实现

Herbivore：草食动物

Carnivore：食肉动物

Bison：['baisn]，美洲或欧洲的野牛

下面实际代码演示了一个电脑游戏中创建不同动物的抽象工厂。尽管在不同大陆下动物物种是不一样的，但动物间的关系仍然保留了下来。

//  Abstract Factory pattern -- Real World example  
using  System;
//  "AbstractFactory"
abstract   class  ContinentFactory
{
  // Methods
  abstract public Herbivore CreateHerbivore();
  abstract public Carnivore CreateCarnivore();
}
  // Methods
  abstract public Herbivore CreateHerbivore();
  
  abstract public Carnivore CreateCarnivore();
}
}
//  "ConcreteFactory1"
class  AfricaFactory : ContinentFactory
{
  // Methods
  override public Herbivore CreateHerbivore()
  { return new Wildebeest(); }

  override public Carnivore CreateCarnivore()
  { return new Lion(); }
}
  // Methods
  override public Herbivore CreateHerbivore()
  
  { return new Wildebeest(); }
  override public Carnivore CreateCarnivore()
  
  { return new Lion(); }
}
//  "ConcreteFactory2"
class  AmericaFactory : ContinentFactory
{
  // Methods
  override public Herbivore CreateHerbivore()
  { return new Bison(); }

  override public Carnivore CreateCarnivore()
  { return new Wolf(); }
}
  // Methods
  override public Herbivore CreateHerbivore()
  
  { return new Bison(); }
  override public Carnivore CreateCarnivore()
  
  { return new Wolf(); }
}
//  "AbstractProductA"
abstract   class  Herbivore
{
}
}
//  "AbstractProductB"
abstract   class  Carnivore
{
  // Methods
  abstract public void Eat( Herbivore h );
}
  // Methods
  abstract public void Eat( Herbivore h );
}
}
//  "ProductA1"
class  Wildebeest : Herbivore
{
}
}
//  "ProductB1"
class  Lion : Carnivore
{
  // Methods
  override public void Eat( Herbivore h )
  {
    // eat wildebeest
    Console.WriteLine( this + " eats " + h );
  }
}
  // Methods
  override public void Eat( Herbivore h )
  
  {
    // eat wildebeest
    Console.WriteLine( this + " eats " + h );
  }
    // eat wildebeest
    Console.WriteLine( this + " eats " + h );
  }
  }
}
//  "ProductA2"
class  Bison : Herbivore
{
}
}
//  "ProductB2"
class  Wolf : Carnivore
{
  // Methods
  override public void Eat( Herbivore h )
  {
    // Eat bison
    Console.WriteLine( this + " eats " + h );
  }
}
  // Methods
  override public void Eat( Herbivore h )
  
  {
    // Eat bison
    Console.WriteLine( this + " eats " + h );
  }
    // Eat bison
    Console.WriteLine( this + " eats " + h );
  }
  }
}
//  "Client"
class  AnimalWorld
{
  // Fields
  private Herbivore herbivore;
  private Carnivore carnivore;

  // Constructors
  public AnimalWorld( ContinentFactory factory )
  {
    carnivore = factory.CreateCarnivore();
    herbivore = factory.CreateHerbivore();
  }

  // Methods
  public void RunFoodChain()
  { carnivore.Eat(herbivore); }
}
  // Fields
  private Herbivore herbivore;
  
  private Carnivore carnivore;

  
  // Constructors
  public AnimalWorld( ContinentFactory factory )
  
  {
    carnivore = factory.CreateCarnivore();
    herbivore = factory.CreateHerbivore();
  }
    carnivore = factory.CreateCarnivore();
    herbivore 
    herbivore = factory.CreateHerbivore();
  }
  }
  // Methods
  public void RunFoodChain()
  
  { carnivore.Eat(herbivore); }
}
/// <summary>
///  GameApp test class
/// </summary>
///  GameApp test class
/// </summary>
class  GameApp
{
  public static void Main( string[] args )
  {
    // Create and run the Africa animal world
    ContinentFactory africa = new AfricaFactory();
    AnimalWorld world = new AnimalWorld( africa );
    world.RunFoodChain();

    // Create and run the America animal world
    ContinentFactory america = new AmericaFactory();
    world = new AnimalWorld( america );
    world.RunFoodChain();
  }
}
  public static void Main( string[] args )
  
  {
    // Create and run the Africa animal world
    ContinentFactory africa = new AfricaFactory();
    AnimalWorld world = new AnimalWorld( africa );
    world.RunFoodChain();

    // Create and run the America animal world
    ContinentFactory america = new AmericaFactory();
    world = new AnimalWorld( america );
    world.RunFoodChain();
  }
    // Create and run the Africa animal world
    ContinentFactory africa = new AfricaFactory();
    AnimalWorld world 
    AnimalWorld world = new AnimalWorld( africa );
    world.RunFoodChain();

    
    world.RunFoodChain();
    // Create and run the America animal world
    ContinentFactory america = new AmericaFactory();
    world 
    world = new AnimalWorld( america );
    world.RunFoodChain();
  }
    world.RunFoodChain();
  }
}

抽象工厂的另外一个例子：

如何设计抽象类工厂留作思考。



七、 "开放－封闭"原则

"开放－封闭"原则要求系统对扩展开放，对修改封闭。通过扩展达到增强其功能的目的。对于涉及到多个产品族与多个产品等级结构的系统，其功能增强包括两方面：

增加产品族：Abstract Factory很好的支持了"开放－封闭"原则。

增加新产品的等级结构：需要修改所有的工厂角色，没有很好支持"开放－封闭"原则。

综合起来，抽象工厂模式以一种倾斜的方式支持增加新的产品，它为新产品族的增加提供方便，而不能为新的产品等级结构的增加提供这样的方便。

 

 

参考文献：

阎宏，《Java与模式》，电子工业出版社

[美]James W. Cooper，《C#设计模式》，电子工业出版社

[美]Alan Shalloway  James R. Trott，《Design Patterns Explained》，中国电力出版社

[美]Robert C. Martin，《敏捷软件开发－原则、模式与实践》，清华大学出版社

[美]Don Box, Chris Sells，《.NET本质论 第1卷：公共语言运行库》，中国电力出版社

3h随然吧
关注
专栏目录
c#详解抽象工厂
01-02
详细讲解了抽象工厂在c#中的应用，
简单工厂模式、工厂模式、抽象工厂模式案例（C++实现）
04-10
在这个压缩包中，包含了三种工厂模式的C++实现：简单工厂模式、工厂方法模式以及抽象工厂模式。让我们一一探讨这些模式。 1. 简单工厂模式： 简单工厂模式是一种静态工厂方法，它提供一个公共的工厂类来创建对象。...
抽象工厂（Abstract Factory）模式
zhyl_yg的专栏
04-26 1688
抽象工厂（Abstract Factory）模式作者：吕震宇一、 抽象工厂（Abstract Factory）模式抽象工厂模式是所有形态的工厂模式中最为抽象和最具一般性的一种形态。为了方便引进抽象工厂模式，引进一个新概念：产品族（Product Family）。所谓产品族，是指位于不同产品等级结构，功能相关联的产品组成的家族。如图：图中一共有四个产品族，分布于三个不同的产品等级结构中。只要指明一个
设计模式之抽象工厂（Abstract Factory）模式
绝圣弃智-零的博客
11-02 310
转自：http://www.cnblogs.com/edisonchou/p/6777901.html   抽象工厂（Abstract Factory）模式 上一篇的工厂方法模式引入了工厂等级结构，解决了在原来简单工厂模式中工厂类职责太重的原则，但是由于工厂方法模式的每个工厂只生产一类产品，可能会导致系统中存在大量的工厂类，从而增加系统开销。那么，我们应该怎么来重构？似乎，我们可以考虑将一些...
设计模式 - 抽象工厂模式(abstract factory pattern) 详解
Mystra
05-26 3114
抽象工厂模式(abstract factory pattern) 详解 本文地址:http://blog.csdn.net/caroline_wendy/article/details/27091671 参考工厂模式:http://blog.csdn.net/caroline_wendy/article/details/27081511 抽象工厂模式: 提供一个接口, 用于创建相关或依赖对象的家族, 而不需要明确指定具体类.具体方法:1. 提供一个
Java设计模式之抽象工厂模式实例详解
08-29
Java设计模式之抽象工厂模式实例详解 Java设计模式之抽象工厂模式实例详解是指在软件设计中，通过提供一个创建一系列相关或相互依赖对象的接口，且无需指定它们具体的类别的方式来生成这些对象的模式。抽象工厂模式...
抽象工厂模式+工厂方法模式+策略模式+类图实现手机加工厂
12-04
本文将探讨三个重要的设计模式：抽象工厂模式、工厂方法模式以及策略模式，并结合一个实际的场景——手机加工厂，来具体阐述它们的应用。 首先，我们来看**抽象工厂模式**。这个模式主要用于创建相关或依赖对象的...
Python设计模式之抽象工厂模式
09-21
抽象工厂模式是设计模式中的一种结构型模式，它提供了一种创建对象集合的方式，这些对象来自同一族系，且它们之间具有相互依赖的关系。在Python中，我们可以利用面向对象编程来实现这一模式。抽象工厂模式的主要目的...
抽象工厂模式uml类图
03-07
java设计模式 抽象工厂模式详解 一张图让你彻底明白抽象工厂模式
C# 语言实现 抽象工厂 功能
08-31
用C# 实现的抽象工厂例子，用vs2005打开
Java设计模式圣经连载（03）－抽象工厂模式
weixin_33849942的博客
12-06 139
1.3 抽象工厂（Abstract Factory）模式    抽象工厂模式可以向客户端提供一个接口，使得客户端在不必指定产品具体类型的情况下，创建多个产品族中的产品对象。这就是抽象工厂模式的用意。    每个模式都是针对一定问题的解决方案。抽象工厂模式面对的问题是多产品等级结构的系统设计。    在学习抽象工厂具体实例之前，应该明白两个重要的概念：产品族和产品等级。    产品族：是指位于不同产...
C# 抽象工厂模式
ryancao530的博客
12-08 508
抽象工厂模式 (Abstract Factory Pattern) 抽象工厂是一个超级工厂，它能创建其他工厂。这种类型的设计模式属于创建型模式，它提供了一种创建对象的方式。 主要解决：主要解决接口选择的问题。 何时使用：系统的产品有多个的产品族，而系统只消费其中某一族产品。 如何解决：在一个产品族里面，定义多个产品。 实例如下图所示： class Program { static void Main(string[] args) { To
C#设计模式-抽象工厂
鹏鹏2077
06-30 181
抽象工厂模式的学习体会到了类与类之间的解耦重要性，并且类与类之间的联系也因为解耦看着更加的简洁易懂，首先先了解到抽象工厂的定义是什么：提供一个创建一系列相关或相互依赖对象的接口，而无须指定它们具体的类。抽象工厂模式又称为Kit模式，属于对象创建型模式，是工厂方法模式的升级版，在有多个业务品种、业务分类时，通过抽象工厂模式产生需要的对象是一种非常好的解决方式。 对于应用我也只是简单的看着那些例子来的，但是就是这些例子特别的简洁，易懂所以就用所学的这个对于数据库访问与修改的小例子来进行一个小展示，如有不足之处
用C#实现抽象工厂模式
weixin_30245867的博客
07-19 141
大家都知道，在开发中，如果用好了某种模式，那效率…… 嘿嘿 我就不说了 进入正题吧： 以下都为源代码，可直接拷贝，然后自己研究 由于是讲解，所以只涉及基本的架构 项目名为：AbstractFactoryMode 1.建立抽象总工厂 using System; using System.Collections.Generic; using Syst...
C#设计模式之 --抽象工厂
C++++ ++
08-11 245
抽象工厂模式： 抽象工厂(Abstract Factory): 提供一个创建一系列相关或相互依赖对象的接口，而无需指定他们的具体类。 结构图： AbstractProductA 和 AbstractProductB 是两个抽象产品 之所以是抽象，是因为它们都有可能又两种不同的实现。而 ProductA1，ProductA2和ProductB1，ProductB2 就是对两个抽象产品的具体分类的...
C#编程模式之抽象工厂模式
最新发布
weixin_50236846的博客
04-17 619
模式介绍：今天我们介绍第三中编程模式，抽象工厂模式。顾名思义还是和工厂相关，同时也与工厂方法模式有着千丝万缕的联系，但是其本质又与工厂方法模式大相径庭。这里先来简单介绍下二者的区别，以免混淆。抽象工厂模式：提供一个接口，用于创建一系列相关的对象，而无需指定具体的类。它适用于需要一次性创建多个相关对象，以形成一个族群。抽象工厂模式通常由抽象工厂、具体工厂、抽象产品和具体产品组成。通过切换具体工厂实现类，可以改变整个族群。
C#设计模式——抽象工厂（Abstract Factory Pattern）
qq_57198771的博客
12-28 2130
抽象工厂模式是一个创建型设计模式，本文讲解抽象工厂模式相关知识、抽象类和接口知识、C#中实现简单的抽象工厂模式，并展示扩展产品族和产品等级的情况。
抽象工厂模式详解与应用
"本文主要介绍了设计模式中的抽象工厂模式，这是一种用于创建相关或依赖对象家族的接口，使得客户端无需指定具体类即可创建一系列产品的方法。文章通过产品等级结构和产品族的概念来阐述抽象工厂模式的核心，并提供...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值