最常用的设计模式----工厂模式家族（简单工厂模式，工厂方法模式，抽象工厂模式）

工厂模式是个系列，分为简单工厂模式，工厂方法模式，抽象工厂模式，这三种模式也非常常用。这些模式最最经典的就例子就是设计计算器。

简单工厂模式

严格的说，简单工厂模式并不是23种常用的设计模式之一，它只算工厂模式的一个特殊实现。简单工厂模式在实际中的应用相对于其他2个工厂模式用的还是相对少得多，因为它只适应很多简单的情况，最最重要的是它违背了我们在概述中说的开放-封闭原则。因为每次你要新添加一个功能，都需要在生switch-case 语句（或者if-else 语句）中去修改代码，添加分支条件。

简单工厂模式角色分配：

Creator（产品创建者）
简单工厂模式的核心，它负责实现创建所有实例的内部逻辑。工厂类可以被外界直接调用，创建所需的产品对象。
Product （产品抽象类）
简单工厂模式所创建的所有对象的父类，它负责描述所有实例所共有的公共接口。
Concrete Product （具体产品）
是简单工厂模式的创建目标，所有创建的对象都是充当这个角色的某个具体类的实例。

简单工厂模式uml图：

考虑下面一个事例：加入你是一个商人，你做的的是手机生意。现在你生产android 手机和iphone等，考虑到以后你可能还会生产其他手机例如ubuntu手机。假定你选择了简单工厂模式来实现。那么显然，我们需要所有产品的抽象基类（Product）即是Phone类：

[cpp]view plain copy
class Phone   
{  
public:  
    virtual ~Phone(){};//在删除的时候防止内存泄露  
    virtual void call(string number) = 0;  
};  

然后我们需要具体的产品类 Concrete Product： AndroidPhone 和 IosPhone

[cpp]view plain copy
class AndroidPhone : public Phone   
{  
public:  
    void call(string number){ cout<<"AndroidPhone is calling..."<<endl;}  
};  
  
class IosPhone : public Phone  
{  
public:  
    void call(string number) { cout<<"IosPhone is calling..."<<endl;}  
};  

最后我们需要Creator

[cpp]view plain copy
class PhoneFactory  
{  
public:  
    Phone* createPhone(string phoneName)  
    {  
        if(phoneName == "AndroidPhone")  
        {  
            return new AndroidPhone();  
        }else if(phoneName == "IosPhone")  
        {  
            return new IosPhone();  
        }  
  
        return NULL;  
    }  
};  

客户端这样实现：

[cpp]view plain copy
void main()  
{  
    PhoneFactor factory;  
    Phone* myAndroid = factory.createPhone("AndroidPhone");  
    Phone* myIPhone = factory.createPhone("IosPhone");  
    if(myAndroid)  
    {  
        myAndroid->call("123");  
        delete myAndroid;  
        myAndroid = NULL;  
    }  
  
    if(myIPhone)  
    {  
        myIPhone->call("123");  
        delete  myIPhone;  
        myIPhone = NULL;  
    }  
}  

这就是简单工厂方法，把所有的创建交给creator,creator 通过switch-case(或者if-else)语句来选择具体创建的对象。简单明了。但是就如上面所说，它最致命的问题的违背了开放-封闭原则。每次你要新添加一个功能，都要修改factor里面的createPhone代码。但是工厂方法模式可以解决这个问题。

工厂方法模式

个人觉得工厂方法模式在工厂模式家族中是用的最多模式。上面说过了，如果简单工厂模式，要添加一个新功能，比如我现在要增加WinPhone 的生产，那么我要修改PhoneFactory中的createPhone 中的分支判断条件。这违背了开放-封闭原则，那为什么不能将创建方法放到子类中呢？

工厂方法的定义就是：定义一个用于创建对象的接口，让子类决定实例化哪一个类，工厂方法使一个类的实例化延迟到其子类。

工厂方法模式角色：

抽象工厂(Creator)角色：是工厂方法模式的核心，与应用程序无关。任何在模式中创建的对象的工厂类必须实现这个接口。
具体工厂(Concrete Creator)角色：这是实现抽象工厂接口的具体工厂类，包含与应用程序密切相关的逻辑，并且受到应用程序调用以创建产品对象。
抽象产品(Product)角色：工厂方法模式所创建的对象的超类型，也就是产品对象的共同父类或共同拥有的接口。
具体产品(Concrete Product)角色：这个角色实现了抽象产品角色所定义的接口。某具体产品有专门的具体工厂创建，它们之间往往一一对应。

工厂方法模式uml图：

看定义看的晕乎乎的？那么我们来看代码：

产品接口，以及其相应的子类。

[cpp]view plain copy
class Phone   
{  
public:  
    virtual ~Phone(){};//在删除的时候防止内存泄露  
    virtual void call(string number) = 0;  
};  
  
class AndroidPhone : public Phone   
{  
public:  
    void call(string number){ cout<<"AndroidPhone is calling..."<<endl;}  
};  
  
class IosPhone : public Phone  
{  
public:  
    void call(string number) { cout<<"IosPhone is calling..."<<endl;}  
};  

上面这个和简单工厂方法还是一样的。接下来不一样的来了...

[cpp]view plain copy
class PhoneFactory  
{  
public:  
    virtual ~PhoneFactory(){};  
    virtual Phone* createPhone() = 0;  
};  
  
class AndroidPhoneFactory : public PhoneFactory  
{  
public:  
    virtual Phone* createPhone()  
    {  
        return new AndroidPhone();  
    }  
};  
  
class IosPhoneFactory : public PhoneFactory  
{  
public:  
    virtual Phone* createPhone()  
    {  
        return new IosPhone();  
    }  
};  

工厂方法将PhoneFactory抽象成了基类，PhoneFactory的createPhone不在像以前那样将所有的判断塞到里面。而是改由其子类来实现创建功能，这感觉就是权力下放。

客户端：

[cpp]view plain copy
void main()  
{  
    PhoneFactory*  androidCreator = new AndroidPhoneFactory();  
    PhoneFactory*  iosCreator = new IosPhoneFactory();  
    Phone*  myAndroid = androidCreator->createPhone();  
    Phone* myIPhone = iosCreator->createPhone();  
    if(myAndroid)  
    {  
        myAndroid->call("123");  
        delete myAndroid;  
        myAndroid = NULL;  
    }  
  
    if(myIPhone)  
    {  
        myIPhone->call("123");  
        delete  myIPhone;  
        myIPhone = NULL;  
    }  
  
    delete androidCreator;  
    delete iosCreator;  
}  

在工厂方法模式中，核心工厂类不在负责产品的创建，而是将具体的创建工作交给子类去完成。也就是后所这个核心工厂仅仅只是提供创建的接口，具体实现方法交给继承它的子类去完成。当我们的系统需要增加其他新功能时，只需要继承PhoneFactory这个类，并且实现createPhone接口。不需要对原工厂PhoneFactory进行任何修改，这样很好地符合了“开放-封闭“原则。

虽然工厂方法模式满足了"开放-封闭”原则，但是这个模式也仍然有缺点：每次增加一个产品时，都需要增加一个具体类和对象实现工厂，是的系统中类的个数成倍增加，在一定程度上增加了系统的复杂度，同时也增加了系统具体类的依赖。这并不是什么好事。

抽象工厂模式

在工厂方法模式中，其实我们有一个潜在意识的意识。那就是我们生产的都是同一类产品，例如我们生产的都是手机！那么现在假如现在我们又要生产平板了了呢？那么就要用到抽象工厂模式。我抽象工厂模式也用的比较多在工厂模式家族中，仅次于工厂方法模式。在了解抽象工厂模式之前，还是老生常谈的理清下产品等级结构和产品簇的概念。下面的图还是老图。但是我讲讲我的理解：

产品等级结构：产品的等级结构也就是产品的继承结构。我理解就是同一类产品，比如手机是一个系列，有android手机，ios手机，win手机，那么这个抽象类手机和他的子类就构成了一个产品等级结构。那其他的平板显然不是和手机一个系列的，一个平板，一个是手机，所以他们是不同的产品等级结构。
产品族: 在抽象工厂模式中，产品族是指由同一个工厂生产的，位于不同产品等级结构中的一组产品。比如分为android产品，和ios产品。其中一个ios产品包含ios手机和ios平板。显然ios手机和ios平板不是同一个产品等级结构的，因为一个是手机，一个是平板。但他们是同一个产品簇---都是ios产品。

希望大家通过上面的例子大家明白了这两个概念。
抽象工厂模式的Uml 图：

接着上面的话题，现在假如我要增加对平板的支持，那么我们肯定先添加两个产品等级结构，一个是手机，一个是平板：

[cpp]view plain copy
//产品等级结构--手机  
class Phone   
{  
public:  
    virtual ~Phone(){};//在删除的时候防止内存泄露  
    virtual void call(string number) = 0;  
};  
  
class AndroidPhone : public Phone   
{  
public:  
    void call(string number){ cout<<"AndroidPhone is calling..."<<endl; }  
};  
  
class IosPhone : public Phone  
{  
public:  
    void call(string number) { cout<<"IosPhone is calling..."<<endl; }  
};  
  
//产品等级结构--平板  
class Pad  
{  
public:  
    virtual ~Pad(){};  
    virtual void playMovie() = 0;  
};  
  
class AndroidPad : public Pad  
{  
public:  
    virtual void playMovie(){ cout<<"AndriodPad is playing movie..."<<endl; }  
};  
  
class IosPad : public Pad  
{  
public:  
    virtual void playMovie(){ cout<<"IosPad is playing movie..."<<endl; }  
};  

然后具体的工厂我们整个工厂是生产移动设备的所以我们取名为MobileFactory,然后工厂可以生产平板和手机，故有了createPhone 和createPad两个接口。

[cpp]view plain copy
class MobileFactory  
{  
public:  
    virtual ~MobileFactory(){};  
    virtual Phone* createPhone() = 0;  
    virtual Pad* createPad() = 0;  
};  

接着是 android 产品簇的工厂类，负责生产android 的手机和平板：

[cpp]view plain copy
class AndroidFactory : public MobileFactory  
{  
public:  
    Phone* createPhone()  
    {  
        return new AndroidPhone();  
    }  
    Pad* createPad()  
    {  
        return new AndroidPad();  
    }  
};  

接着是ios的产品簇的工厂类，负责生产ios的手机和平板：

[cpp]view plain copy
class IosFactory : public MobileFactory  
{  
public:  
    Phone* createPhone()  
    {  
        return new IosPhone();  
    }  
  
    Pad* createPad()  
    {  
        return new IosPad();  
    }  
};  

最后客户端这样实现：

[cpp]view plain copy
void main()  
{  
    MobileFactory*  androidCreator = new AndroidFactory();  
    MobileFactory*  iosCreator = new IosFactory();  
    Phone*  myAndroidPhone = androidCreator->createPhone();  
    Pad* myAndroidPad = androidCreator->createPad();  
    Phone* myIosPhone = iosCreator->createPhone();  
    Pad* myIosPad = iosCreator->createPad();  
      
    myAndroidPhone->call("123");  
    myAndroidPad->playMovie();  
  
    myIosPhone->call("123");  
    myIosPad->playMovie();  
    //这里没有做释放和判断，请自己判断和释放  
}  

总结：

抽象工厂模式适用于那些有多种产品的产品簇，并且每次使用其中的某一产品簇的产品。

缺点：抽象工厂模式的添加新功能也非常麻烦，比工厂方法模式都还要复杂的多。

优点：当一个产品族中的多个对象被设计成一起工作时，它能够保证客户端始终只使用同一个产品族中的对象。

上面说到抽象工厂和工厂方法模式的功能添加都非常复杂，那么我们有没有什么办法可以简化呢？答案是肯定有的：那就是工厂模式 + 配置文件 + 反射。具体怎么实现，请看下回分解。