当前位置：首页 > article >正文

工厂方法模式 (Factory Method Pattern)

article 2025/3/16 19:38:45

工厂方法模式 (Factory Method Pattern) 是一种创建型设计模式，它定义了一个创建对象的接口，但由子类决定要实例化的类是哪一个。工厂方法模式让类的实例化推迟到子类。

一、基础

1. 意图

定义一个创建对象的接口，但由子类决定要实例化的类是哪一个。
工厂方法模式让类的实例化推迟到子类。

2. 适用场景

当一个类不知道它所必须创建的对象的类的时候。
当一个类希望由它的子类来指定它所创建的对象的时候。
当类将创建对象的职责委托给多个帮助子类中的某一个，并且你希望将哪一个帮助子类是代理者这一信息局部化的时候。

3. 结构

抽象产品（Product）：定义了产品的接口，是所有具体产品类的父类。
具体产品（ConcreteProduct）：实现了抽象产品接口，是具体被创建的对象。
抽象工厂（Creator）：声明了工厂方法，该方法返回一个抽象产品类型的对象。抽象工厂可以有一些具体的方法，用于处理与创建对象相关的通用逻辑。
具体工厂（ConcreteCreator）：实现了抽象工厂中的工厂方法，负责创建具体的产品对象。

二、进阶

1. 工厂方法模式的优点

让代码独立于特定类，从而更容易扩展和维护。
将对象的创建和使用分离，从而提高代码的灵活性。
提供一种创建对象的标准方式，从而提高代码的可读性和可维护性。

2. 工厂方法模式的缺点

可能会导致类的数量增加，从而增加代码的复杂性。
可能会降低代码的性能，因为每次创建对象时都需要调用工厂方法。

3. 工厂方法模式的应用

广泛应用于各种框架和库中，例如 Spring 框架、Hibernate 框架等。
可以用于开发各种应用程序，例如游戏、图形用户界面等。

三、关键点

1. 工厂方法模式的实现

可以通过接口或抽象类来实现。
可以通过静态方法或实例方法来实现。

2. 工厂方法模式的扩展

可以与其他设计模式结合使用，例如单例模式、原型模式等。
可以扩展为抽象工厂模式，从而支持创建一系列相关或依赖的对象。

四、易错点

1. 工厂方法模式的滥用

工厂方法模式不应该被滥用，只有在需要将对象的创建和使用分离时才应该使用工厂方法模式。

2. 性能问题

工厂方法模式可能会降低代码的性能，因为每次创建对象时都需要调用工厂方法。

五、核心代码

1. 工厂方法模式的简单实现

// Product
class Product {
public:
    virtual void use() = 0;
};

// ConcreteProductA
class ConcreteProductA : public Product {
public:
    void use() override {
        std::cout << "Using ConcreteProductA" << std::endl;
    }
};

// ConcreteProductB
class ConcreteProductB : public Product {
public:
    void use() override {
        std::cout << "Using ConcreteProductB" << std::endl;
    }
};

// Creator
class Creator {
public:
    virtual Product* createProduct() = 0;
};

// ConcreteCreatorA
class ConcreteCreatorA : public Creator {
public:
    Product* createProduct() override {
        return new ConcreteProductA();
    }
};

// ConcreteCreatorB
class ConcreteCreatorB : public Creator {
public:
    Product* createProduct() override {
        return new ConcreteProductB();
    }
};

// Client
int main() {
    Creator* creator = new ConcreteCreatorA();
    Product* product = creator->createProduct();
    product->use();

    delete creator;
    delete product;

    return 0;
}

5.2 工厂方法模式的扩展实现

// Product
class Product {
public:
    virtual void use() = 0;
};

// ConcreteProductA
class ConcreteProductA : public Product {
public:
    void use() override {
        std::cout << "Using ConcreteProductA" << std::endl;
    }
};

// ConcreteProductB
class ConcreteProductB : public Product {
public:
    void use() override {
        std::cout << "Using ConcreteProductB" << std::endl;
    }
};

// Creator
class Creator {
public:
    virtual Product* createProduct() = 0;
};

// ConcreteCreatorA
class ConcreteCreatorA : public Creator {
public:
    Product* createProduct() override {
        return new ConcreteProductA();
    }
};

// ConcreteCreatorB
class ConcreteCreatorB : public Creator {
public:
    Product* createProduct() override {
        return new ConcreteProductB();
    }
};

// Client
int main() {
    Creator* creator = new ConcreteCreatorA();
    Product* product = creator->createProduct();
    product->use();

    delete creator;
    delete product;

    creator = new ConcreteCreatorB();
    product = creator->createProduct();
    product->use();

    delete creator;
    delete product;

    return 0;
}