工厂模式

专门利用一个工厂类，根据输入的参数，创建不同类的实例的模式，叫工厂模式。
工厂类拥有一个静态函数，用于创建产品类的对象，返回值为父类的指针（指向子类的对象）
静态函数中，根据传入的参数，构建具体的子类对象

1 简单工厂模式

简单工厂模式只有一个工厂类，工厂类中有一个静态函数，根据参数创建产品类的实例；
例子：
工厂类：

class PhoneFactory
        {
            static Phone* Create( int nType)  //工厂类的静态函数，根据入参，决定创建哪个类的实例
            {
                switch( nType )
                {
                case 0:
                    {
                        Phone* p = new HuaWei;
                        p->CreatePhone();
                        return p;
                        break;
                    }
                case 1:
                    {
                        Phone* p = new Iphone;
                        p->CreatePhone();
                        return p;
                        break;
                    }
                default:
                    {
                        return NULL;
                        break;
                    }
                }
            }
        };

产品类：

class Phone  //产品类的父类，定义统一接口
{
public:
      virtual void CreatePhone() = 0;
};
class HuaWei : public Phone //产品类1
{
public:
　　virtual void  CreatePhone()
　　{
        cout<< " create Huawei" << endl;
    }
};

class Iphone : public Phone //产品类2
{
public:
　　virtual void  CreatePhone()
　　{
        cout<< " create iphone" << endl;
　　}
};

优点：结构简单、清晰；通过参数就知道创建哪个；
缺点：类型多了以后工厂类方法（switch···case··）复杂，新增一个产品类，需要修改工厂方法。破坏开放-封闭原则；

2 工厂方法模式

解决了简单工厂模式增减/删除产品类，都要修改工厂方法的缺点。
构建工厂类的父类，父类提供工厂的统一接口，将具体的创建任务下放到子类
工厂类：

class PhoneFactory   //工厂父类
    {
    public:
        virtual Phone* Create( int nType) = 0;
    };

    class HuaweiFactory : public PhoneFactory //工厂子类1
    {
    public:
        Phone* Create( int nType)
        {
            cout<< " create Huawei" << endl;
        }
    };

    class IPhoneFactory : public PhoneFactory //工厂子类2
    {
    public:
        Phone* Create( int nType)
        {
            cout<< " create iphone" << endl;
        }
    };

使用：

int main()
    {
        PhoneFactory* factor = new HuaweiFactory();
        Phone* pPhone = factor->Create();
    }

3 抽象工厂模式

抽象工厂模式相当于工厂方法模式，比如要制造高端手机机型 上述的工厂方法模式不满足
需要给工厂方法模式的父类 增加接口，比如：

   class PhoneFactory   //工厂父类
    {
    public:
        virtual Phone* Create( int nType) = 0;
        virtual Phone* CreateHighPricePhone( int nType) = 0;
    };