Factory模式与Abstract Factory模式

本文大部分从网络摘抄，出处就不一一列明了，原作者还请见谅.

Factory与Abstract Factory模式的区别：

Factory模式概述：

一个抽象产品类，可以派生出多个具体产品类。

一个抽象工厂类，可以派生出多个具体工厂类。

每个具体工厂类只能创建一个具体产品类的实例。

Abstract Factory模式概述：

多个抽象产品类，每个抽象产品类可以派生出多个具体产品类。

一个抽象工厂类，可以派生出多个具体工厂类。

每个具体工厂类可以创建多个具体产品类的实例。

区别：

Factory模式只有一个抽象工厂类，而Abstract Factory有多个， Factory模式的具体工厂类只能创建一个具体产品类的实例，而Abstract Factory模式的具体工厂类可以创建多个具体产品类的实例。

Factory模式：

作用：定义一个用于创建对象的接口，让子类决定实例化哪一个类。Factory method使一个类的实例化延迟到其子类。

Factory解决的问题：

问题1：为了提高内聚（Cohesion）和松耦合（Coupling），我们经常会抽象出一些类的公共接口以形成抽象基类或者接口。这样我们可以通过声明一个指向基类的指针来指向实际的子类，以达到多态的目的。这里很容易出现的一个问题就是n多的子类继承自抽象基类，我们不得不在每次要用到子类的地方都要编写诸如new xxx的代码。这里带来了两个问题：1.客户程序员必须知道实际子类的名称（当系统复杂后，命名将是一个很不好处理的问题，为了处理可能名字冲突，有的命名可能并不是具有很好的可读性和可记忆性）。2.程序的扩展性和维护性将变得越来越困难。

问题2：

父类中并不知道要具体实例化哪一个具体的子类。即A类用到抽象基类B，但是A并不知道要实例化B的哪一个子类，但是A类的子类C知道。在A中我们没有办法直接使用new xxx这样的语句来创建，因为我们根本就不知道new什么。

Factory模式：

作用是，定义一个用于创建对象的借口，让子类决定实例化哪一个类，Factory Method使一个类的实例化延迟到其子类:

#ifndef FACOTRY_H__
#define FACTROY_H__

class Product
{
public:
    Product(){}
    virtual ~Product(){}
};

class ConcreateProduct
    :public Product
{
public:
    ConcreateProduct();
    virtual ~ConcreateProduct();
};

class Factory
{
public:
    Factory(){}
    virtual ~Factory(){}

    void AnOperation();

protected:
    virtual Product* FactoryMethod() = 0;
};

class ConcreateFactory : public Factory
{
public:
    ConcreateFactory();
    virtual ~ConcreateFactory();

protected:
    virtual Product* FactoryMethod();
};
#endif

抽象工厂设计模式

作用：提供一个创建一系列相关或相互依赖对象的借口，而无需制定他们具体的类。

#pragma  once
class AbstractProductA
{
public:
    AbstractProductA() {};
    virtual ~AbstractProductA(){};
};

class ConcreateProductA1: public AbstractProductA
{
public:
    ConcreateProductA1();
    virtual ~ConcreateProductA1();
};

class ConcreateProductA2 : public AbstractProductA
{
public:
    ConcreateProductA2();
    virtual ~ConcreateProductA2();
};

class AbstractProductB
{
public:
    AbstractProductB() {}
    virtual ~AbstractProductB(){}
};

class ConcreateProductB1 : public AbstractProductB
{
public:
    ConcreateProductB1();
    virtual ~ConcreateProductB1();
};

class ConcreateProductB2 : public AbstractProductB
{
public:
    ConcreateProductB2();
    virtual ~ConcreateProductB2();
};

//抽?象?基?类?AbstractFactory，?工?厂?的?抽?象?类?，?生?产?产?品?A和?产?品?B
class AbstractFactory
{
public:
    AbstractFactory(){}
    virtual ~AbstractFactory() {}

    virtual AbstractProductA *CreateProductA() = 0;
    virtual AbstractProductB *CreateProductB() = 0;
};

//派?生?类?ConcreateFactory1,继?承?自?AbstractFactory
//生?产?产?品?A和?产?品?B的?第?一?种?实?现?
class ConcreateFactory1 : public AbstractFactory
{
public:
    ConcreateFactory1();
    virtual ~ConcreateFactory1();

    virtual AbstractProductA* CreateProductA();
    virtual AbstractProductB* CreateProductB();
};

class ConcreateFactory2 : public AbstractFactory
{
public:
    ConcreateFactory2();
    virtual ~ConcreateFactory2();
   
    virtual AbstractProductA* CreateProductA();
    virtual AbstractProductB* CreateProductB();
};