抽象工厂模式(Abstract Factory)

　　GOF：提供一个创建一系列相关或相互依赖对象的接口，而无需指定它们具体的类。

　　类图：

　　

---

　　

　　观察类图，关键就在于左边，即AbstractFactory和它的两个子类。想要理解这个模式，我们可以真的将它看作一个工厂。对于生产家电的工厂，一般要生产电视和洗衣机，但是在美国的家电工厂生产的是等离子电视和全自动洗衣机，在非洲的家电工厂生产的是CRT彩电和半自动洗衣机。把这个例子转换成类似上面的类图就如下：

　　这时，如果想要开工厂，就能从彩电工厂生产标准知道彩电工厂能生产电视和洗衣机，然后根据你在哪个国家来具体决定彩电工厂的类型。

　　AbstractFactory一般是抽象类（但不是绝对的），它定义了必需的接口，而具体接口的实现放到了子类。用户只需知道Factory中有什么接口就行了，剩下就交给多态吧（在设计模式中，很多巧妙的地方就是靠多态实现的）。

　　比如：一群学生要去参观家电工厂的生产过程，则代码如下：

void StudentVisit(AbstractFactory& factory) {
    factory.MakeTV();
    factory.MakeWasher();
}

int main() {
    USAFactory factory;
    StudentVisit(factory);

    ;
}

　　这里实际传入的参数是美国家电工厂，则实际调用的是美国家电工厂的MakeTV()和MakeWasher()。

　　适用性：

• 一个系统要独立于它的产品的创建,组合和表示时。（我们只需要知道有什么接口，而不需要了解子类是怎么实现的）
• 一个系统要由多个产品系列中的一个来配置时。（比如上面电视有多种，但是美国彩电工厂要的是等离子电视）
• 当你要强调一系列相关的产品对象的设计以便进行联合使用时。（彩电工厂需要生产电视和洗衣机，这两个就是相关的产品）
• 当你提供一个产品类库，而只想显示它们的接口而不是实现时。（我们只需要调用抽象类的接口，而不需要到子类中看具体的方法）

　　优点 + 缺点：

• 它分离了具体的类。
• 它使得易于交换产品系列。改变使用的具体工厂就能生产不同的产品。
• 它有利于产品的一致性。每一个具体工厂生产的都是同一等级的产品。
• 难以支持新种类的产品。如果要在抽象类中增加接口，每个具体工厂都要进行修改。

　

---

　　最后以一个创建游戏场景的例子结束，该游戏场景会产生地形，光源，植被。

　　类图：

　　代码：

　　先看看Product，即类图右边的类：

　　地形类：

class Terrain {
public:
    ;
};

class DesertTerrain : public Terrain {
public:
    DesertTerrain() {
        m_type = "Desert";
    }
    string GetType() const {
        return m_type;
    }
private:
    string m_type;
};

class MountainTerrain : public Terrain {
public:
    MountainTerrain() {
        m_type = "Mountain";
    }
    string GetType() const {
        return m_type;
    }
private:
    string m_type;
};

　　光源类：

class Light {
public:
    ;
};

class SpotLight : public Light{
public:
    SpotLight() {
        m_type = "Spot Light";
    }
    string GetType() const {
        return m_type;
    }
private:
    string m_type;
};

class DirectionLight : public Light {
public:
    DirectionLight() {
        m_type = "Direction Light";
    }
    string GetType() const {
        return m_type;
    }
private:
    string m_type;
};

　　植被类：

class Plant {
public:
    ;
};

class TreePlant : public Plant {
public:
    TreePlant() {
        m_type = "Tree";
    }
    string GetType() const {
        return m_type;
    }
private:
    string m_type;
};

class CactusPlant : public Plant {
public:
    CactusPlant() {
        m_type = "Cactus";
    }
    string GetType() const {
        return m_type;
    }
private:
    string m_type;
};

　　

　以下就看工厂类：

class GameSceneFactory {
public:

    ;
    ;
    ;
};

class DesertSceneFactory : public GameSceneFactory {
public:

    Terrain* MakeTerrain() const {
        return new DesertTerrain();
    }

    Light* MakeLight() const {
        return new DirectionLight();
    }

    Plant* MakePlant() const {
        return new CactusPlant();
    }
};

class MountainSceneFactory : public GameSceneFactory {
public:

    Terrain* MakeTerrain() const {
        return new MountainTerrain();
    }

    Light* MakeLight() const {
        return new SpotLight();
    }

    Plant* MakePlant() const {
        return new TreePlant();
    }
};

　　以下就是具体的使用：

class Game {
public:
    void createScene(GameSceneFactory& factory) {
        m_terrain = factory.MakeTerrain();
        m_light = factory.MakeLight();
        m_plant = factory.MakePlant();
        print();
    }
    void print() {
        cout << "------Game Scene------" << endl;
        cout << "Terrain: " << m_terrain->GetType() << endl;
        cout << "Light: " << m_light->GetType() << endl;
        cout << "Plant: " << m_plant->GetType() << endl;
    }
private:
    Terrain* m_terrain;
    Light* m_light;
    Plant* m_plant;
};

int main() {
    Game game;
    MountainSceneFactory factory;
    game.createScene(factory);
}

　　结果：

---

　　小结：抽象工厂模式是一个比较常用的模式，需要好好掌握。利用真实生活中的工厂就比较好理解该模式的运作，但真正要掌握还得在日常编码中的适当场合使用。