工厂模式

一、简单工厂

定义：简单工厂模式的工厂类是根据提供给它的参数，返回的是几个可能产品中的一个类的实例。通常情况下返回的类都有一个公共的类和公共的方法。

#include<iostream>
#include<string>
using namespace std;
using std::cin;
using std::cout;
using std::endl;
using std::string;


class SingleFactory
{
public:
    virtual void show() = 0;
};


class SingleFactoryA : public SingleFactory
{
public:
    void show()
    {
        cout<<"SingleFactoryA"<<endl;
    }
};


class SingleFactoryB :public SingleFactory
{
    void show()
    {
        cout<<"SingleFactoryB"<<endl;
    }
};


class Factory
{
public:
    static SingleFactory *Create(string &str)
    {
        if(str == "AA")
        {
            return new SingleFactoryA();
        }
        else if(str == "BB")
        {
            return new SingleFactoryB();
        }
        else
        {
            return NULL;
        }
    }
};


int main()
{
    SingleFactory *sf = NULL;
    std::string str = "AA";
    sf =  Factory::Create(str);
    sf->show();
    return 0;
}

二、工厂方法

1、定义：工厂方法定义了一个创建对象的接口，但由子类决定要实例化的类是哪一个。工厂方法让类把实例化推迟到子类。

  决定：并不是指模式允许子类本身在运行时做出决定，而是指在编写创建者类时，不需要知道实际创建的产品是哪一个。

2、简单工厂与工厂方法的差异

（1）、简单工厂把全部的事情在一个地方都处理完了，然而工厂方法却是创建一个框架，让子类决定如何实现。

（2）、简单工厂的方法可以将对象的创建封装起来，但是简单工厂没有工厂方法的弹性，因为简单工厂不能变更正在创建的产品。

3、设计原则（依赖倒置原则）

要依赖抽象，不要依赖具体类

 如何在OO设计中违偶反依赖倒置原则：

（1）、变量不可以持有具体类的引用（如果使用new，就会持有具体类的引用）；

（2）、不要让类派生自具体类（如果派生自具体类，就会依赖具体类，应该派生自抽象（接口或者抽象类））；

（3）、不要覆盖基类中已经实现的方法（如果覆盖，那么基类就不是一个真正适合继承的抽象）

4、工厂方法代码（C++）

#include<iostream>
#include<string>
using namespace std;
using std::cin;
using std::cout;
using std::endl;
using std::string;


class SingleFactory
{
public:
    virtual void show() = 0;
};


class SingleFactoryA : public SingleFactory
{
public:
    void show()
    {
        cout<<"SingleFactoryA"<<endl;
    }
};


class SingleFactoryB :public SingleFactory
{
    void show()
    {
        cout<<"SingleFactoryB"<<endl;
    }
};


class Factory
{
public :
   virtual SingleFactory *Create() = 0;


};


class FactoryA : public Factory
{
public :
    virtual SingleFactory *Create()
    {
        return new SingleFactoryA();
    }
};


class FactoryB : public Factory
{
public :
    virtual SingleFactory *Create()
    {
        return new SingleFactoryB();
    }
};




int main()
{
    SingleFactory *sf = NULL;
    Factory *fa = NULL;


    fa = new FactoryA();
    sf = fa->Create();
    sf->show();


    delete sf;
    delete fa;


    fa = new FactoryB();
    sf = fa->Create();
    sf->show();
    return 0;
}

三、抽象工厂

抽象工厂模式提供一个接口，用于创建相关或依赖对象的家族，而不需要明确指定具体类。