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

最新推荐文章于 2024-09-22 21:41:33 发布

_Jungle

最新推荐文章于 2024-09-22 21:41:33 发布

阅读量576

点赞数

分类专栏：设计模式[Design Pattern] 文章标签： Design Pattern 设计模式

本文链接：https://blog.csdn.net/zhouk517/article/details/29847861

版权

设计模式[Design Pattern] 专栏收录该内容

5 篇文章 0 订阅

订阅专栏

在走进抽象工厂之前，得先走进简单工厂。

一、简单工厂（Factory）模式

1. 概述

提供一个类，由它负责根据一定的条件创建某一具体类的实例。

2. 解决的问题

简单工厂模式的实质是由一个工厂类根据传入的参数，动态决定应该创建哪一个产品类（这些产品类继承自一个父类或接口）的实例。专门定义一个类来负责创建其他类的实例，被创建的实例通常都具有共同的父类。它又称为静态工厂方法模式，属于类的创建型模式。

3. 模式结构

Factory模式分为两种情况，分别如下图所示。

图1 Factory模式结构示意图1

图1所以的Factory模式经常在系统开发中用到，但是这并不是Factory模式的最大威力所在（因为这可以通过其他方式解决这个问题）。Factory模式不单是提供了创建对象的接口，其最重要的是延迟了子类的实例化（第二个问题），以下是这种情况的一个Factory的结构示意图：

图2 Factory模式结构示意图2

图2中关键中Factory模式的应用并不是只是为了封装对象的创建，而是要把对象的创建放到子类中实现：Factory中只是提供了对象创建的接口，其实现将放在 Factory的子类ConcreteFactory中进行。这是图2和图1的区别所在。

模式中的角色

Product：

简单工厂模式所创建的所有对象的父类，它负责描述所有实例所共有的公共接口。

ConcreteProduct：

简单工厂模式的创建目标，所有创建的对象都是充当这个角色的某个具体类的实例。一般来讲它是抽象产品类的子类，实现了抽象产品类中定义的所有接口方法。

Factory：

声明生成一系列抽象产品的方法。

ConcreteFactory：

执行抽象产品的方法，生成不同的具体产品。

4.实现

给出一个实现的小例子。

classFactory
{
public:
         virtual ~Factory() = 0;
         virtual Product* CreatProduct() = 0;
 
protected:
         Factory();
 
private:
 
 
};
 
classConcreteFactory: public Factory
{
public:
         ~ConcreteFactory();
         ConcreteFactory();
         Product* CreatProduct();
 
protected:
 
private:
 
};
 
Factory::Factory()
{
 
}
Factory::~Factory()
{
 
}
ConcreteFactory::ConcreteFactory()
{
         cout<<"ConcreteFactory.."<<endl;
}
ConcreteFactory::~ConcreteFactory()
{
 
}
Product*ConcreteFactory::CreatProduct()
{
         return new ConcreteProduct();
}
 
classProduct
{
public:
         virtual ~Product() = 0;
 
protected:
         Product();
 
private:
 
 
};
 
class ConcreteProduct: public Product
{
public:
         ~ConcreteProduct();
         ConcreteProduct();
 
protected:
 
private:
 
};
 
Product::Product()
{
 
}
Product::~Product()
{
 
}
 
ConcreteProduct::ConcreteProduct()
{
         cout<<"ConcreteProduct..."<<endl;
}
 
ConcreteProduct::~ConcreteProduct()
{
 
}

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

提供创建对象的接口。与工厂方法类似，但此处返回的一系列相关产品。实现过程同样推延到子系列类去实现。与工厂方法的区别在于他们的层次模型。工厂方法的抽象基类只有儿子，而抽象工厂模式却是有孙子，而且每个儿子的儿子们之间有相互关联依赖关系。

1. 概述

提供一个创建一系列相关或相互依赖对象的接口，而无需指定它们具体的类。

2. 解决的问题

一个系统要独立于他的产品的创建、组合和表示时；
一个系统要多个产品系统中的一个来配置时；
当要强调一系列相关的产品对象的设计以便进行联合使用时；
当提供一个产品类库，而只想显示他们的接口而不是实现时。

3. 模式结构

Abstract Factory典型模式如下图所示。

图3 AbstractFactory模式结构示意图

模式中的角色：

抽象工厂（Abstract Factory）：

声明生成一系列抽象产品的方法

具体工厂（Concrete Factory）：

执行生成一系列抽象产品的方法，生成一系列具体的产品

抽象产品（Abstract Product）：

为这一系列的某一种产品声明接口

具体产品（Product）：

定义具体工厂生成的具体产品的对象，实现产品接口

客户（Client）：

我们的应用程序客户端（不要理解成人），使用抽象产品和抽象工厂生成对象。

4. 实现

给出一个实现的小例子。

产品类层次：

classAbstractProductA
{
public:
         virtual ~AbstractProductA();
protected:
         AbstractProductA();
private:
};
 
classAbstractProductB
{
public:
         virtual ~AbstractProductB();
protected:
         AbstractProductB();
private:
 
};
 
classProductA1: public AbstractProductA
{
public:
         ProductA1();
         ~ProductA1();
protected:
 
private:
 
};
 
classProductA2: public AbstractProductA
{
public:
         ProductA2();
         ~ProductA2();
};
 
classProductB1: public AbstractProductB
{
public:
         ProductB1();
         ~ProductB1();
};
 
classProductB2: public AbstractProductB
{
public:
         ProductB2();
         ~ProductB2();
};

抽象工厂类：

classAbstractProductA;
classAbstractProductB;
 
classAbstractFactory
{
public:
         virtual ~AbstractFactory();
         virtual AbstractProductA *CreateProductA() = 0;
         virtual AbstractProductB *CreateProductB() = 0;
protected:
         AbstractFactory();
 
};
 
classConcreteFactory1: public AbstractFactory
{
public:
         ConcreteFactory1();
         ~ConcreteFactory1();
         AbstractProductA * CreateProductA();
         AbstractProductB * CreateProductB();
        
};
 
classConcreteFactory2: public AbstractFactory
{
public:
         ConcreteFactory2();
         ~ConcreteFactory2();
         AbstractProductA * CreateProductA();
         AbstractProductB * CreateProductB();
        
};
 
AbstractProductA*ConcreteFactory1::CreateProductA()
{
         return new ProductA1();
}
AbstractProductB*ConcreteFactory1::CreateProductB()
{
         return new ProductB1();
}
 
AbstractProductA*ConcreteFactory2::CreateProductA()
{
         return new ProductA2();
}
AbstractProductB*ConcreteFactory2::CreateProductB()
{
         return new ProductB2();
}