【设计模式】创建型模式-Abstract Factory模式

功能

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

解决

• 主要解决：主要解决接口选择的问题
• 何时使用：系统的产品有多于一个的产品族，而系统只消费其中某一族的产品
• 如何解决：在一个产品族里面，定义多个产品
• 关键代码：在一个工厂里聚合多个同类产品

与工厂方法的区别

工厂方法是在解决一个产品多个层级方面的事情
抽象工厂致力于解决多个产品多个层级方面的是事情

优缺点

• 优点：保证客户端始终只使用一个产品族中的对象
• 缺点：扩展困难

应用场景

• 应用实例：汽车是由很多零件组成的，比如引擎、轮胎、方向盘等等。现在如果我们是轮胎生产方，要生产宝马轮胎和奔驰轮胎，要用工厂方法还是抽象工厂实现呢？答案是：工厂方法。轮胎是一个产品，宝马轮胎和奔驰轮胎是 2 个不同层级的轮胎，所以用工厂方法解决就足够。假如现在我们是汽车生产方，要生产宝马汽车和奔驰汽车，汽车又包含轮胎和方向盘等等，要用哪个来实现？既然是上面的是工厂方法，那这个就用抽象工厂，因为这涉及到多个产品（轮胎、方向盘等等）和 2 个层级（宝马和奔驰）。
• 使用场景：
  • QQ换皮肤，一整套一起换
  • 生成不同操作系统的程序
  • 游戏中不同级别（简单，中等，困难，噩梦）的怪物类
• 注意事项：产品族难扩展，产品等级易扩展

简单示例代码部分

Abstract_Factory.hpp

//Abstrcat_Factory.hpp
#ifndef _ABSTRACTFACTORY_H_
#define _ABSTRACTFACTORY_H_
#include <iostream>
class AbstractProductA{
public:
    AbstractProductA(){}
    ~AbstractProductA(){}
};
class AbstractProductB{
public:
    AbstractProductB(){}
    ~AbstractProductB(){}
};
class ProductA1:public AbstractProductA{
public:
    ProductA1(){
        std::cout<<"ProductA1..."<<std::endl;
    }
    ~ProductA1(){}
};
class ProductA2:public AbstractProductA{
public:
    ProductA2(){
        std::cout<<"ProductA2..."<<std::endl;
    }
    ~ProductA2(){}
};
class ProductB1:public AbstractProductB{
public:
    ProductB1(){
        std::cout<<"ProductB1..."<<std::endl;
    }
    ~ProductB1(){}
};
class ProductB2:public AbstractProductB{
public:
    ProductB2(){
        std::cout<<"ProductB2..."<<std::endl;
    }
    ~ProductB2(){}
};
class AbstractFactory{
public:
    AbstractFactory(){}
    ~AbstractFactory(){}
    virtual AbstractProductA* CreateProductA()=0;
    virtual AbstractProductB* CreateProductB()=0;
};
class ConcreteFactory1:public AbstractFactory{
public:
    ConcreteFactory1(){}
    ~ConcreteFactory1(){}
    AbstractProductA* CreateProductA(){
        return new ProductA1();
    }
    AbstractProductB* CreateProductB(){
        return new ProductB1();
    }
};
class ConcreteFactory2:public AbstractFactory{
public:
    ConcreteFactory2(){}
    ~ConcreteFactory2(){}
    AbstractProductA* CreateProductA(){
        return new ProductA2();
    }
    AbstractProductB* CreateProductB(){
        return new ProductB2();
    }
};
#endif

main.cpp

#include "Abstract_Factory.hpp"
#include <iostream>
using namespace std;
int main(){
    AbstractFactory* cf1 = new ConcreteFactory1();
    cf1->CreateProductA();
    cf1->CreateProductB();
    AbstractFactory* cf2 = new ConcreteFactory2();
    cf2->CreateProductA();
    cf2->CreateProductB();
    return 0;
}