02_23 种设计模式之《抽象工厂模式》

文章目录

一、抽象工厂模式

抽象工厂模式（Abstract Factory Pattern）隶属于设计模式中的创建型模式，用于产品族的构建。抽象工厂是指当有多个抽象角色时使用的一种工厂模式。抽象工厂模式可以向客户端提供一个接口，使客户端在不必指定产品的具体情况下，创建多个产品族中的产品对象。工厂模式中的每一个形态都是针对一定问题的解决方案，工厂方法针对的是多个产品系列结构；而抽象工厂模式针对的是多个产品族结构，一个产品族内有多个产品系列。提供一个创建一系列相互依赖对象的接口，而无需指定它们具体的类。

主要目的解决：主要解决接口问题的选择。

在抽象工厂模式当中，客户端不再负责对象的创建，而是把这个责任丢给具体的工厂类，客户端只负责对对象的调用，从而明确各个类的职责。

抽象工厂模式（Abstract Factory Pattern）是一种创建型设计模式，它提供了一种创建一系列相关或相互依赖对象的接口，而不需要指定它们的具体类。这种模式非常适合在需要生成多个对象族，而这些对象族之间存在某种关系时使用。

抽象工厂模式的结构

抽象工厂模式通常包含以下角色：

抽象工厂（Abstract Factory）：定义创建一系列抽象产品的方法的接口。
具体工厂（Concrete Factory）：实现抽象工厂接口，生成一系列的具体产品。
抽象产品（Abstract Product）：定义产品对象的接口。
具体产品（Concrete Product）：实现抽象产品的接口，由具体工厂创建。

应用场景

抽象工厂模式适用于以下情况：

需要生成一系列相关或相互依赖的对象：这些对象通常属于相同的产品族，例如不同的操作系统界面控件。
需要强调一系列对象的创建，而不是单个对象的创建。
提供一个产品类库，所有的产品以同样的接口出现，使客户端不依赖于具体实现。
当系统需要提供可交换主题或皮肤时，如不同的操作系统主题。

示例代码（C++）

cpp 复制代码

// 抽象产品A
class AbstractProductA {
public:
    virtual void Use() = 0;
};

// 具体产品A1
class ConcreteProductA1 : public AbstractProductA {
public:
    void Use() override {
        std::cout << "Using A1" << std::endl;
    }
};

// 具体产品A2
class ConcreteProductA2 : public AbstractProductA {
public:
    void Use() override {
        std::cout << "Using A2" << std::endl;
    }
};

// 抽象产品B
class AbstractProductB {
public:
    virtual void Use() = 0;
};

// 具体产品B1
class ConcreteProductB1 : public AbstractProductB {
public:
    void Use() override {
        std::cout << "Using B1" << std::endl;
    }
};

// 具体产品B2
class ConcreteProductB2 : public AbstractProductB {
public:
    void Use() override {
        std::cout << "Using B2" << std::endl;
    }
};

// 抽象工厂
class AbstractFactory {
public:
    virtual AbstractProductA* CreateProductA() = 0;
    virtual AbstractProductB* CreateProductB() = 0;
};

// 具体工厂1
class ConcreteFactory1 : public AbstractFactory {
public:
    AbstractProductA* CreateProductA() override {
        return new ConcreteProductA1();
    }
    AbstractProductB* CreateProductB() override {
        return new ConcreteProductB1();
    }
};

// 具体工厂2
class ConcreteFactory2 : public AbstractFactory {
public:
    AbstractProductA* CreateProductA() override {
        return new ConcreteProductA2();
    }
    AbstractProductB* CreateProductB() override {
        return new ConcreteProductB2();
    }
};

// 客户端代码
int main() {
    AbstractFactory* factory = new ConcreteFactory1();
    AbstractProductA* productA = factory->CreateProductA();
    AbstractProductB* productB = factory->CreateProductB();
    productA->Use();
    productB->Use();
    delete productA;
    delete productB;
    delete factory;
    return 0;
}

注意事项

扩展性 ：如果需要添加新的产品族，需要修改抽象工厂和所有具体工厂类，这可能会影响现有代码。
复杂性：模式可能会增加系统的复杂性，因为需要定义和管理多个抽象和具体类。