浅谈设计模式之一——简单工厂、工厂、抽象工厂

这些天意识自身的不足，看着几个同学跳槽后的高薪，实在是惭愧。毕业两年，仍一事无成，差距也正逐渐体现出来。人们常说，设计模式是一个初级程序员到高级程序员的必经之路。为了补强自己，重新研究了GOF四人帮的<23种设计模式>，其实以前看过，只是没看懂，最近重新研究了一番，理解了一些，希望用通俗易懂的语言把它写下来，或许对初学者有帮助，对自己也有提升。
设计模式分为创建型模式、行为型模式和结构型模式。创建型模式又分为5种，分别是抽象工厂（Abstract Factory）、工厂模式（Factory）、建造者模式（Builder）、原型模式（Prototype）和单例类模式（Singleton）。
注：GOF四人帮的<23种设计模式>中没有简单工厂。
这里从创建型模式讲起，首先讲简单工厂、工厂以及抽象工厂。
一、简单工厂模式（Simple Factory）
首先先上uml图，简单工厂很简单，但不够灵活，其实大家经常用，只是不知道这就是简单工厂。uml图相信大家都看得懂。

解析uml：一个父类产品，几个子类继承父类产品，一个具体工厂依赖具体产品。
这样做的好处就是简单，坏处也很明显，不够灵活，扩展性相对差。实现可以用多态来实现。多态有三个条件：一是父类的virtual，二是子类的覆盖（要求函数名、参数、返回值都要一模一样），三是父类的指针或引用指向子类的对象。
下面给出可执行的参考代码：
SimpleFactory.h

#pragma once
#incldue<iostream>
using namespace std;

const int PRODOCTA=1;
const int PRODOCTB=2;
class AbstractProduct;

class Factory
{
public:
//construct
Factory(void);
//create a product
AbstractProduct * CreateProduct(int flag);

//destruct
~Factory(void);
};

class AbstractProduct
{
public:
virtual void Operation() = 0;

};

class ProductA:public AbstractProduct
{
public:
void Operation();

};

class ProductB:public AbstractProduct
{
public:
void Operation();

};

SimpleFactory.cpp

#include "Factory.h"
Factory::Factory(void)
{
}

Factory::~Factory(void)
{
}

AbstractProduct* Factory::CreateProduct(int flag)
{
switch(flag)
{
case PRODOCTA:
return new ProductA();
break;
case PRODOCTB:
return new ProductB();
break;
default:
return NULL;
break;
}



}

void ProductA::Operation()
{
cout<<"ProductA"<<endl;
}


void ProductB::Operation()
{
cout<<"ProductB"<<endl;
}

main.cpp

#include "Factory.h"
int main(int argc,char** argv)
{
    Factory f;
    f.CreateProduct(PRODOCTA)->Operation();
    f.CreateProduct(PRODOCTB)->Operation();

    getchar();
    return 0;
}

执行结果：

二、工厂模式（Factory）
同样先上uml图。

uml解析：一个抽象工厂，有若干子工厂泛化，一个抽象产品，若干子产品，工厂跟产品是依赖关系。跟简单工厂相比，多了抽象工厂，使对象实例化延迟到子类。
可以这样理解工厂模式，有很多电脑厂商，比如联想，华硕，dell，苹果等，如果你比较有钱，要生产一台苹果的笔记本，那么你可以通过AppleFactory生产一个AppleProduct，这样做的好处就是不用再传参数了。
下面给出可以直接运行的示例代码：
Factory.h

#pragma once
#include "SimpleFactory.h"

class Factory
{
public:
    Factory(void);
    ~Factory(void);
public:
    virtual AbstractProduct * CreateProduct() = 0;

};

class ConcreteFactoryA: public Factory
{
public:
    AbstractProduct * CreateProduct();

};

class ConcreteFactoryB: public Factory
{
public:
    AbstractProduct *CreateProduct();

};

Factory.cpp

#include "Factory.h"

Factory::Factory(void)
{
}

Factory::~Factory(void)
{
}

AbstractProduct * ConcreteFactoryA::CreateProduct()
{
    return new ProductA;
}

AbstractProduct * ConcreteFactoryB::CreateProduct()
{
    return new ProductB;
}

main.cpp

#include "Factory.h"

int main(int argc,char** argv)
{
    ConcreteFactoryA *f1;
    f1 = new ConcreteFactoryA();
    ConcreteFactoryB *f2;
    f2 = new ConcreteFactoryB();
    f1->CreateProduct()->Operation();
    f2->CreateProduct()->Operation();

    getchar();
    return 0;
}

运行结果：

三、抽象工厂（Abstract Factory）
一样先上uml
uml解析：跟工厂的区别就是产品也抽象了，不止一个产品，即工厂跟产品都抽象，而且产品的数量大于等于2。可以这么理解，有华硕，dell，联想，苹果等厂商，你要一个苹果的显示器，联想的主板，dell的鼠标，这时你就可以用到抽象工厂，原因是抽象工厂把鼠标，键盘，显示器等否分开了，以便亲你可以自己定制一个。
下面贴出可直接运行的示例代码：
AbstractFactory.h

#pragma once
#include <iostream>
using namespace std;

class AbstractProductA
{
public:
    virtual void Operation() = 0;
};

class AbstractProductB
{
public:
    virtual void Operation() = 0;
};

class ConcreteProductA1:public AbstractProductA
{
public:
    void Operation();

};

class ConcreteProductA2:public AbstractProductA
{
public:
    void Operation();
};

class ConcreteProductB1:public AbstractProductB
{
public:
    void Operation();

};

class ConcreteProductB2:public AbstractProductB
{
public:
    void Operation();
};


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

class AbstractFactoryA:public AbstractFactory
{
public:
    AbstractProductA * CreateProductA();
    AbstractProductB * CreateProductB();
};

class AbstractFactoryB:public AbstractFactory
{
public:
    AbstractProductA * CreateProductA();
    AbstractProductB * CreateProductB();
};

AbstractFactory.cpp

#include "AbstractFactory.h"

AbstractFactory::AbstractFactory(void)
{
}

AbstractFactory::~AbstractFactory(void)
{
}

AbstractProductA * AbstractFactoryA::CreateProductA()
{
    return new ConcreteProductA1();

}
AbstractProductB * AbstractFactoryA::CreateProductB()
{
    return new ConcreteProductB1();

}
AbstractProductA * AbstractFactoryB::CreateProductA()
{
    return new ConcreteProductA2();

}
AbstractProductB * AbstractFactoryB::CreateProductB()
{
    return new ConcreteProductB2();

}


void ConcreteProductA1::Operation()
{
    cout<<"concreteProductA1"<<endl;
}
void ConcreteProductA2::Operation()
{
    cout<<"concreteProductA2"<<endl;
}
void ConcreteProductB1::Operation()
{
    cout<<"concreteProductB1"<<endl;
}
void ConcreteProductB2::Operation()
{
    cout<<"concreteProductB2"<<endl;
}

main.cpp

#include "AbstractFactory.h"

int main(int argc,char** argv)
{
    AbstractFactory* f1 = new AbstractFactoryA();
    AbstractFactory* f2 = new AbstractFactoryB();
    f1->CreateProductA()->Operation();
    f1->CreateProductB()->Operation();
    f2->CreateProductA()->Operation();
    f2->CreateProductB()->Operation();

    getchar();
    return 0;
}

运行结果如图：

好了，到此为止，三种工厂模式就全部介绍完，希望对你有帮助，也希望对自己有帮助，写博客还真是累，给个赞吧O(∩_∩)O~thx