大话设计模式-简单工厂模式、工厂方法模式、抽象工厂模式

简单工厂模式

概念：简单工厂模式是由一个工厂对象决定创建出哪一种产品类的实例。

适合应用于具有多个分支，不同的情况需要生成对应的类，将分支移到工厂类中，减少客户端的复杂度。但如果要新添加一个产品类的话，需要修改工厂类的代码。

// OperationFactory.cpp : 定义控制台应用程序的入口点。
//

#include "stdafx.h"
#include <iostream>
#include <string>
using namespace std;

class Operation{
private:
    int numberA;
    int numberB;
public:
    void setNumberA(int a){
        this->numberA = a;
    }
    void setNumberB(int b){
        this->numberB = b;
    }
    int getNumberA(){
        return numberA;
    }
    int getNumberB(){
        return numberB;
    }
    virtual int getResult()=0;
};

class OperationAdd:public Operation{
public:
    int getResult(){
        return (getNumberA() + getNumberB());
    }
};
class OperationSub:public Operation{
public:
    int getResult(){
        return (getNumberA() - getNumberB());
    }
};
class OperationMul:public Operation{
public:
    int getResult(){
        return (getNumberA() * getNumberB());
    }
};
class OperationDiv:public Operation{
public:
    int getResult(){
        return (getNumberA() / getNumberB());
    }
};

class OperationFactory{
public:
     Operation* createOperation(char ch){
        Operation *p = NULL;
        switch(ch){
        case '+':
            p = new OperationAdd();
            break;
        case '-':
            p = new OperationSub();
            break;
        case '*':
            p = new OperationMul();
            break;
        case '/':
            p = new OperationDiv();
            break;
        }
        return p;
    }
     //单例模式
     static OperationFactory & getInstance(){
         static OperationFactory of;
         return of;
     }
};
int _tmain(int argc, _TCHAR* argv[])
{
    Operation *p;
    p = OperationFactory::getInstance().createOperation('+');
    p->setNumberA(2);
    p->setNumberB(3);
    cout << p->getResult()<< endl;
    return 0;
}

 简单工厂模式在遇到新的类添加时，需要对工厂类进行修改，这未被了开放-封闭原则。

工厂方法模式：

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

工厂方法模式是简单工厂模式的进一步抽象和推广，使用了多态性，保持了简单工厂模式的有点，也克服简单工厂模式的缺点。但是每增加一个类，就要对应的增加该类的工厂类。

// OperationFactory.cpp : 定义控制台应用程序的入口点。
//

#include "stdafx.h"
#include <iostream>
#include <string>
using namespace std;

class Operation{
private:
    int numberA;
    int numberB;
public:
    void setNumberA(int a){
        this->numberA = a;
    }
    void setNumberB(int b){
        this->numberB = b;
    }
    int getNumberA(){
        return numberA;
    }
    int getNumberB(){
        return numberB;
    }
    virtual int getResult()=0;
};

class OperationAdd:public Operation{
public:
    int getResult(){
        return (getNumberA() + getNumberB());
    }
};
class OperationSub:public Operation{
public:
    int getResult(){
        return (getNumberA() - getNumberB());
    }
};
class OperationMul:public Operation{
public:
    int getResult(){
        return (getNumberA() * getNumberB());
    }
};
class OperationDiv:public Operation{
public:
    int getResult(){
        return (getNumberA() / getNumberB());
    }
};

class IOperationFactory{
public:
    virtual Operation * createOperation()=0;
};
class AddFactory:public IOperationFactory{

    Operation* createOperation(){
        return new OperationAdd();
    }
};
class SubFactory:public IOperationFactory{
    Operation* createOperation(){
        return new OperationSub();
    }
};
class MulFactory:public IOperationFactory{
    Operation* createOperation(){
        return new OperationMul();
    }
};
class DivFactory:public IOperationFactory{
    Operation* createOperation(){
        return new OperationDiv();
    }
};
//简单工厂模式
class SimpleFactory{
public:
    IOperationFactory *createOperationFactory(char ch){
        IOperationFactory *pf;
        switch (ch)
        {
        case '+': pf = new AddFactory();break;
        case '-': pf = new SubFactory();break;
        case '*': pf = new MulFactory();break;
        case '/': pf = new DivFactory();break;
        }
        return pf;
    }
    static SimpleFactory& createSimpleFactory(){
        static SimpleFactory sf;
        return sf;
    }
};
int _tmain(int argc, _TCHAR* argv[])
{
    IOperationFactory *pf = SimpleFactory::createSimpleFactory().createOperationFactory('+');
    Operation *p = pf->createOperation();
    p->setNumberA(2);
    p->setNumberB(3);
    cout << p->getResult()<< endl;
    return 0;
}

 抽象工厂模式

抽象工厂模式：提供一个创建一系列相关或相互依赖对象的接口，而无需指定他们具体的类。

适用场景：易于交换产品系列。让具体的创建实例过程与客服端分离，客户端通过他们的抽象接口操纵实例，产品的具体类名被具体工厂实现分离，不会出现在客户代码中。

// OperationFactory.cpp : 定义控制台应用程序的入口点。
//

#include "stdafx.h"
#include <iostream>
#include <string>
using namespace std;

class IUser{

public:
    virtual void inserUser()=0;
    virtual IUser* getUserByID(int id)=0;
};
class IDepartment{
public:
    virtual void inserDepartment()=0;
    virtual IDepartment* getDepartmentByID(int id)=0;
};
class sqlUser:public IUser{
public:
    void inserUser(){
        cout << "插入sqlUser"<< endl;
    }
    IUser *getUserByID(int id){
        cout << "得到id为"<<id<<"的sqluser"<<endl;
        return NULL;
    }
};
class oracleUser:public IUser{
public:
    void inserUser(){
        cout << "插入oracleUser"<< endl;
    }
    IUser *getUserByID(int id){
        cout << "得到id为"<<id<<"的oracleUser"<<endl;
        return NULL;
    }
};
class sqlDepartment:public IDepartment{
public:
    void inserDepartment(){
        cout << "插入sqlDepartment"<< endl;
    }
    IDepartment *getDepartmentByID(int id){
        cout << "得到id为"<<id<<"的sqlDepartment"<<endl;
        return NULL;
    }
};
class oracleDepartment:public IDepartment{
public:
    void inserDepartment(){
        cout << "插入oracleDepartment"<< endl;
    }
    IDepartment *getDepartmentByID(int id){
        cout << "得到id为"<<id<<"的oracleDepartment"<<endl;
        return NULL;
    }
};

/*
不使用简单工厂模式
class IFactory{
public :
    virtual IUser* createUser()=0;
    virtual IDepartment *createDepartment()=0;
};
class sqlFactory:public IFactory{
public:
    IUser *createUser(){
        cout << "create sqlUser!"<<endl;
        return new sqlUser();
    }
    IDepartment *createDepartment(){
        cout << "create sqlDepartment!"<<endl;
        return new sqlDepartment();
    }
};
class oracleFactory:public IFactory{
public:
    IUser *createUser(){
        cout << "create oracleUser!"<<endl;
        return new oracleUser();
    }
    IDepartment *createDepartment(){
        cout << "create oracleDepartment!"<<endl;
        return new oracleDepartment();
    }
};*/
//简单工厂模式
class DataAccess{
public:

    IUser * createUser(char ch){
        cout << "createUser" << endl;
        IUser *u;
        switch(ch){
        case 's': u = new sqlUser();break;
        case 'o': u = new oracleUser();break;
        }
        return u;
    }

    IDepartment * createDepartment(char ch){
        cout << "createDepartment" << endl;
        IDepartment *d;
        switch(ch){
        case 's': d = new sqlDepartment();break;
        case 'o': d = new oracleDepartment();break;
        }
        return d;
    }
    static DataAccess & createDataAccess(){
        static DataAccess data;
        return data;
    }
};
int _tmain(int argc, _TCHAR* argv[])
{
    //IFactory *f = new sqlFactory();
    //IFactory *f = new oracleFactory();
    char ch = 's';
    IUser *u = DataAccess::createDataAccess().createUser(ch);
    IDepartment *d = DataAccess::createDataAccess().createDepartment(ch);
    u->inserUser();
    d->inserDepartment();
    return 0;
}