有多个工厂模式是为了满足不同的需求，接下来我们从需求角度出发来了解每种工厂模式。

我们以为枪械厂和弹药厂为例。玩过《绝地求生》应该都知道，每种枪支的子弹都有其特定规格，不同枪支子弹规格不一样，子弹是无法通用的。比如：

枪支 子弹规格(mm)
M4A1 5.56
AK47 7.62
Kar98K 7.62
UZI 9.00

我们可能有如下生产需求：
点击查看【processon】

  • 产品系列
    • 枪支系列
      • M4A1、AK47、98K、UZI等种类。
    • 弹药系列
      • 5.56、7.62、9.00等种类。
  • 工厂：以生产线划分。
    • 枪械厂，有枪支生产线的工厂。
    • 弹药厂，有弹药生产线的工厂。

      简单工厂模式：很少用到

      适合这种需求：
      工厂只需要负责生产AK47、M4A1这两款枪支，不要生产弹药，未来也不会需要生产新枪支。

从代码上来说就是，工厂需要负责创建固定几个类的对象，这几个类有相同（间接）基类。

既然情况这么简单，我们也就不需要去区分什么生产线、什么产品系列了，就那么几个产品，搞这么麻烦干嘛。就一个工厂，直接生产就行了。

UML

点击查看【processon】

代码设计

  1. enum GunType {
  2.     GunType_AK47,
  3.     GunType_M4A1,
  4. };
  6. struct Gun{
  7.     virtual Gun* justShow() = 0;    //没子弹，只能用来show
  8. }
  10. struct M4A1 : Gun {        //AK47类似。
  11.     void Gun* justShow(){ return this; }
  12. };
  14. struct GunFactory {
  15.     Gun* produce(GunType t) {
  16.         switch (t) {
  17.             case M4A1:    return new M4A1();
  18.             case AK47:    return new AK47();
  19.             default:    return NULL;
  20.         }
  21.     }
  22. };
  24. int main() {
  25.     GunFactory factory;
  26.     factory.produce(GunType_AK47)->justShow();    //仅做示范，忽略动态内存泄露的问题
  27.     factory.produce(GunType_M4A1)->justShow();    //仅做示范，忽略动态内存泄露的问题
  28. }

工厂方法模式：Factory method

一般情况的需求都比简单工厂复杂，因此简单工厂模式也不列入我们的工厂模式中了。

更一般的需求是：工厂需要负责所有类型枪支的生产包括未来的新型枪支。
从代码上来说就是，工厂需要负责创建某一个基类所有派生类对象。

如果按照简单工厂模式，虽然可以满足需求，但是很勉强，第一，因为需要创建的对象类型可能很多，工厂会很臃肿，第二，如果出现新类型，就需要改动工厂，这不是明智的选择。
这时候就需要工厂方法模式了。

UML

点击查看【processon】

代码设计

  1. struct Gun {
  2.     virtual Gun* justShow() = 0;
  3. };
  5. struct AK47 : Gun{                
  6.     Gun* justShow(){ return this; }    //还是没有子弹，只能show了。
  7. };
  9. struct GunFactory {                    //专门负责造枪支
  10.     virtual Product *produce() = 0;
  11. };
  13. struct FactoryAK47 : GunFactory {    //FactoryM4A1类似。
  14.     Gun *produce(){
  15.         return new AK47();
  16.     }
  17. };
  18. int main() {
  19.     GunFactory *factoryAK47 = new FactoryAK47() , *factoryM4A1 = new FactoryM4A1();
  20.     factoryAK47->produce();        //多态
  21.     factoryM4A1->produce();        //多态
  22. }

抽象工厂模式：Abstract factory

可能还会有比工厂方法更复杂一点的需求，比如：
工厂需要同时负责生产枪支和它对应的弹药，有同学可能会想，为啥不分开工厂生产？我们应该从需求出发，这样的需求是合理，所以我们就应该要满足。
从代码上说就是，工厂的每次创建，需要创建一组不同“系列”的对象，这些对象之间有很紧密的关系。

这时候，就需要抽象工厂模式了。

UML

点击查看【processon】

代码设计

  1. struct Gun {
  2.     virtual Gun* load(Bullet*) = 0;
  3.     virtual Gun* fire() = 0;
  4. };
  6. struct Bullet {
  7.     virtual void shoot() = 0;
  8. };
  10. struct AK47 : Gun {                    //M4A1类似。
  11.     Gun* fire(Bullet*){                //逻辑就不写了，必须要上556的子弹。
  12.         return this;
  13.     }
  14.     Gun* fire(){
  15.         return this
  16.     }
  17. };
  19. struct Bullet762 : Bullet {            //Bullet556类似。
  20.     void shoot() { }
  21. };
  23. struct WeaponFactory {                    //枪支弹药制造商
  24.     virtual Gun* produceGun() = 0;
  25.     virtual Bullet* produceBullet() = 0;
  26. };
  28. struct FactoryAK47 : WeaponFactory {     //FactoryM4A1类似
  29.     Gun* produceGun(){
  30.         return new AK47();
  31.     }
  32.     Bullet* produceBullet(){
  33.         return new Bullet762();
  34.     }
  35. };
  37. int main() {
  38.     GunFactory *factoryAK = new FactoryAK(), *factoryM4A1 = new FactoryM4A1();
  40.     Gun* pGun47 = factoryAK.produceGun();
  41.     Bullet* pBulletAK = factoryAK.produceBullet();
  43.     Gun* pM4A1 = FactoryM4A1.produceGun();
  44.     Bullet* pBulletM4A1 = FactoryM4A1.produceBullet();
  46.     //多态：相同静态类型的Gun、Bullet，fire出来却不一样。
  47.     pGun47->load(pBulletAK)->fire();
  48.     pM4A1->load(pBulletM4A1)->fire();
  49. }

总结

这几个工厂模式，其实就是满足了生产不同复杂度的对象。

  • 简单工厂模式：生产固定几个类的对象。
  • 工厂方法模式：这个一个基类所有派生类的对象。
  • 抽象工厂模式：一次创建一组对象。