设计模式之工厂模式

工厂模式（Factory Pattern） 是一种创建型设计模式，它提供了一种创建对象的接口，但由子类决定要实例化的类是哪一个。工厂模式将对象的创建过程封装起来，使得客户端不需要知道具体的对象创建细节，只需要通过工厂来获取对象。

几个工厂模式概念，最好先从理解简单工厂模式开始

工厂模式的类型	解释
简单工厂模式	提供一个方法，根据参数创建不同类型的对象。一个抽象产品类
工厂方法模式	定义一个创建对象的接口，由子类来决定实例化哪个类。一个抽象工厂类+一个抽象产品类
抽象工厂模式	提供一个接口，用于创建一系列相关或依赖的对象，而无需指定具体的类。一个抽象工厂类+多个抽象产品类

1. 简单工厂模式（Simple Factory）
   简单工厂模式 描述了一个类， 它拥有一个包含大量条件语句的构建方法， 可根据方法的参数来选择对何种产品进行初始化并将其返回。

假设要创建不同类型的“汽车”，例如“宝马”和“奥迪”。

#include <iostream>
#include <memory>

// 抽象产品
class Car {
public:
    virtual void drive() = 0;
    virtual ~Car() {}
};

// 具体产品1
class BMW : public Car {
public:
    void drive() override {
        std::cout << "Driving a BMW!" << std::endl;
    }
};

// 具体产品2
class Audi : public Car {
public:
    void drive() override {
        std::cout << "Driving an Audi!" << std::endl;
    }
};

// 工厂类
class CarFactory {
public:
    static std::shared_ptr<Car> createCar(const std::string& type) {
    	// 大量的条件语句，也包括switch
        if (type == "BMW") {
            return std::make_shared<BMW>();
        } else if (type == "Audi") {
            return std::make_shared<Audi>();
        } else {
            return nullptr;
        }
    }
};

int main() {
    auto bmw = CarFactory::createCar("BMW");
    bmw->drive();  // 输出: Driving a BMW!

    auto audi = CarFactory::createCar("Audi");
    audi->drive();  // 输出: Driving an Audi!

    return 0;
}

简单工厂模式违背了开闭原则，每次添加一个新的产品时，都需要修改工厂类的源代码，增加新的条件判断来实例化新产品类。
由此需要引入后续的两种工厂模式：

• 工厂方法模式

• 抽象工厂模式

2. 工厂方法模式（Factory Method）
   工厂方法是一种创建型设计模式， 其在父类中提供一个创建对象的方法， 允许子类决定实例化对象的类型。
   简单工厂通常没有子类。 但当从一个简单工厂中抽取出子类后， 它看上去就会更像经典的工厂方法模式了。

同样是“汽车”的例子，不同的是我们使用工厂方法来创建不同类型的汽车。

#include <iostream>
#include <memory>

// 抽象产品
class Car {
public:
    virtual void drive() = 0;
    virtual ~Car() {}
};

// 具体产品1
class BMW : public Car {
public:
    void drive() override {
        std::cout << "Driving a BMW!" << std::endl;
    }
};

// 具体产品2
class Audi : public Car {
public:
    void drive() override {
        std::cout << "Driving an Audi!" << std::endl;
    }
};

// 抽象工厂类
class CarFactory {
public:
    virtual std::shared_ptr<Car> createCar() = 0;
    virtual ~CarFactory() {}
};

// 符合开闭原则
// 具体工厂1
class BMWFactory : public CarFactory {
public:
    std::shared_ptr<Car> createCar() override {
        return std::make_shared<BMW>();
    }
};

// 具体工厂2
class AudiFactory : public CarFactory {
public:
    std::shared_ptr<Car> createCar() override {
        return std::make_shared<Audi>();
    }
};

int main() {
    // 使用BMW工厂创建BMW汽车
    std::shared_ptr<CarFactory> factory = std::make_shared<BMWFactory>();
    auto bmw = factory->createCar();
    bmw->drive();  // 输出: Driving a BMW!

    // 使用Audi工厂创建Audi汽车
    factory = std::make_shared<AudiFactory>();
    auto audi = factory->createCar();
    audi->drive();  // 输出: Driving an Audi!

    return 0;
}

工厂方法模式允许通过不同的子类工厂来创建对象。每个工厂可以创建不同的产品实例。

3. 抽象工厂模式（Abstract Factory）
   抽象工厂模式提供了一个接口，允许创建一系列相关的产品，而不需要明确指定它们的具体类。抽象工厂通常用于创建一组相关或依赖的对象。

假设我们需要创建不同类型的“汽车”和“摩托车”：

#include <iostream>
#include <memory>

// 抽象产品：汽车
class Car {
public:
    virtual void drive() = 0;
    virtual ~Car() {}
};

// 抽象产品：摩托车
class Motorcycle {
public:
    virtual void ride() = 0;
    virtual ~Motorcycle() {}
};

// 具体产品：BMW汽车
class BMWCar : public Car {
public:
    void drive() override {
        std::cout << "Driving a BMW car!" << std::endl;
    }
};

// 具体产品：Audi汽车
class AudiCar : public Car {
public:
    void drive() override {
        std::cout << "Driving an Audi car!" << std::endl;
    }
};

// 具体产品：BMW摩托车
class BMWMotorcycle : public Motorcycle {
public:
    void ride() override {
        std::cout << "Riding a BMW motorcycle!" << std::endl;
    }
};

// 具体产品：Audi摩托车
class AudiMotorcycle : public Motorcycle {
public:
    void ride() override {
        std::cout << "Riding an Audi motorcycle!" << std::endl;
    }
};

// 抽象工厂
class VehicleFactory {
public:
    virtual std::shared_ptr<Car> createCar() = 0;
    // 新增了一个新的抽象函数createMotorcycle()（自行车）
    virtual std::shared_ptr<Motorcycle> createMotorcycle() = 0;
    virtual ~VehicleFactory() {}
};

// 具体工厂：BMW工厂
class BMWFactory : public VehicleFactory {
public:
    std::shared_ptr<Car> createCar() override {
        return std::make_shared<BMWCar>();
    }
    // 具体工厂中具体createMotorcycle()
    std::shared_ptr<Motorcycle> createMotorcycle() override {
        return std::make_shared<BMWMotorcycle>();
    }
};

// 具体工厂：Audi工厂
class AudiFactory : public VehicleFactory {
public:
    std::shared_ptr<Car> createCar() override {
        return std::make_shared<AudiCar>();
    }

    std::shared_ptr<Motorcycle> createMotorcycle() override {
        return std::make_shared<AudiMotorcycle>();
    }
};

int main() {
    std::shared_ptr<VehicleFactory> factory = std::make_shared<BMWFactory>();

    auto bmwCar = factory->createCar();
    bmwCar->drive();  // 输出: Driving a BMW car!

    auto bmwMotorcycle = factory->createMotorcycle();
    bmwMotorcycle->ride();  // 输出: Riding a BMW motorcycle!

    factory = std::make_shared<AudiFactory>();

    auto audiCar = factory->createCar();
    audiCar->drive();  // 输出: Driving an Audi car!

    auto audiMotorcycle = factory->createMotorcycle();
    audiMotorcycle->ride();  // 输出: Riding an Audi motorcycle!

    return 0;
}