工厂模式属于创建型模式，大致可以分为三类，简单工厂模式、工厂方法模式、抽象工厂模式。听上去差不多，都是工厂模式。下面一个个介绍，首先介绍简单工厂模式，它的主要特点是需要在工厂类中做判断，从而创造相应的产品。当增加新的产品时，就需要修改工厂类。有点抽象，举个例子就明白了。有一家生产处理器核的厂家，它只有一个工厂，能够生产两种型号的处理器核。客户需要什么样的处理器核，一定要显示地告诉生产工厂。下面给出一种实现方案。
1. enum CTYPE {COREA, COREB}; 2. class SingleCore 3. { 4. public: 5. virtual void Show() = 0; 6. }; 7. //单核A 8. class SingleCoreA: public SingleCore 9. { 10. public: 11. void Show() { cout<<"SingleCore A"<<endl; } 12. }; 13. //单核B 14. class SingleCoreB: public SingleCore 15. { 16. public: 17. void Show() { cout<<"SingleCore B"<<endl; } 18. }; 19. //唯一的工厂，可以生产两种型号的处理器核，在内部判断 20. class Factory 21. { 22. public: 23. SingleCore* CreateSingleCore(enum CTYPE ctype) 24. { 25. if(ctype == COREA) //工厂内部判断 26. return new SingleCoreA(); //生产核A 27. else if(ctype == COREB) 28. return new SingleCoreB(); //生产核B 29. else 30. return NULL;
}
};
这样设计的主要缺点之前也提到过，就是要增加新的核类型时，就需要修改工厂类。这就违反了开放封闭原则：软件实体（类、模块、函数）可以扩展，但是不可修改。于是，工厂方法模式出现了。所谓工厂方法模式，是指定义一个用于创建对象的接口，让子类决定实例化哪一个类。Factory Method使一个类的实例化延迟到其子类。
听起来很抽象，还是以刚才的例子解释。这家生产处理器核的产家赚了不少钱，于是决定再开设一个工厂专门用来生产B型号的单核，而原来的工厂专门用来生产A型号的单核。这时，客户要做的是找好工厂，比如要A型号的核，就找A工厂要；否则找B工厂要，不再需要告诉工厂具体要什么型号的处理器核了。下面给出一个实现方案。
1. class SingleCore 2. { 3. public: 4. virtual void Show() = 0; 5. }; 6. //单核A 7. class SingleCoreA: public SingleCore 8. { 9. public: 10. void Show() { cout<<"SingleCore A"<<endl; } 11. }; 12. //单核B 13. class SingleCoreB: public SingleCore 14. { 15. public: 16. void Show() { cout<<"SingleCore B"<<endl; } 17. }; 18. class Factory 19. { 20. public: 21. virtual SingleCore* CreateSingleCore() = 0; 22. }; 23. //生产A核的工厂 24. class FactoryA: public Factory 25. { 26. public: 27. SingleCoreA* CreateSingleCore() { return new SingleCoreA; } 28. }; 29. //生产B核的工厂 30. class FactoryB: public Factory 31. { 32. public: 33. SingleCoreB* CreateSingleCore() { return new SingleCoreB; } 34. };
工厂方法模式也有缺点，每增加一种产品，就需要增加一个对象的工厂。如果这家公司发展迅速，推出了很多新的处理器核，那么就要开设相应的新工厂。在C++实现中，就是要定义一个个的工厂类。显然，相比简单工厂模式，工厂方法模式需要更多的类定义。
既然有了简单工厂模式和工厂方法模式，为什么还要有抽象工厂模式呢？它到底有什么作用呢？还是举这个例子，这家公司的技术不断进步，不仅可以生产单核处理器，也能生产多核处理器。现在简单工厂模式和工厂方法模式都鞭长莫及。抽象工厂模式登场了。它的定义为提供一个创建一系列相关或相互依赖对象的接口，而无需指定它们具体的类。具体这样应用，这家公司还是开设两个工厂，一个专门用来生产A型号的单核多核处理器，而另一个工厂专门用来生产B型号的单核多核处理器，下面给出实现的代码。
1. //单核 2. class SingleCore 3. { 4. public: 5. virtual void Show() = 0; 6. }; 7. class SingleCoreA: public SingleCore 8. { 9. public: 10. void Show() { cout<<"Single Core A"<<endl; } 11. }; 12. class SingleCoreB :public SingleCore 13. { 14. public: 15. void Show() { cout<<"Single Core B"<<endl; } 16. }; 17. //多核 18. class MultiCore 19. { 20. public: 21. virtual void Show() = 0; 22. }; 23. class MultiCoreA : public MultiCore 24. { 25. public: 26. void Show() { cout<<"Multi Core A"<<endl; } 27. 28. }; 29. class MultiCoreB : public MultiCore 30. { 31. public: 32. void Show() { cout<<"Multi Core B"<<endl; } 33. }; 34. //工厂 35. class CoreFactory 36. { 37. public: 38. virtual SingleCore* CreateSingleCore() = 0; 39. virtual MultiCore* CreateMultiCore() = 0; 40. }; 41. //工厂A，专门用来生产A型号的处理器 42. class FactoryA :public CoreFactory 43. { 44. public: 45. SingleCore* CreateSingleCore() { return new SingleCoreA(); } 46. MultiCore* CreateMultiCore() { return new MultiCoreA(); } 47. }; 48. //工厂B，专门用来生产B型号的处理器 49. class FactoryB : public CoreFactory 50. { 51. public: 52. SingleCore* CreateSingleCore() { return new SingleCoreB(); } 53. MultiCore* CreateMultiCore() { return new MultiCoreB(); } 54. };
简单工厂模式的UML图：
工厂方法的UML图：
抽象工厂模式的UML图：
原文：http://www.cnblogs.com/DamonBlog/p/3897320.html