工厂模式 | 简单工厂模式、工厂模式、抽象工厂模式

简单工厂模式：一个工厂，按照菜单，创建多个实例。
优点：由子类决定具体实例化的对象，把简单的内部逻辑移动到客户端。客户无需关心创建的细节，按需生成实例。
缺点：可扩展性差。需要工厂的逻辑。不符合开闭原则（对于扩展是开放的，但是对于修改是封闭的”）

工厂模式：多个工厂，按照菜单，创建多个实例。（工厂与实例一一对应）
优点：相对于简单工厂，扩展性好。只需增加实例类，和对应的工厂。不需要修改原有代码逻辑。

抽象工厂：
抽象工厂，按照工厂菜单，创建专用工厂
专用工厂，按照产品菜单，创建实例
优点：面向一类产品创建工厂，这一类产品具有统一的属性。例如创建的方式根据形状，或是根据颜色 设计工厂，然后在通过具体的形状或颜色去创建实例。

---

工厂模式：

// 实例类-菜单
class Shape {
public:
    virtual void draw() = 0;
};

class Rectangle : public Shape {
public:
    void draw()override {
        printf("矩形\n");
    }
};

class Square :public Shape {
public:
    void draw()override {
        printf("正方形\n");
    }
};
class Circle : public Shape {
public:
    void draw()override {
        printf("圆形\n");
    }
};
// 工厂类-菜单
class Factory {
public:
    virtual Shape* get() = 0;
};
class RectangleFactory : public Factory {
public:
    Shape* get() override
    {
        return new Rectangle();
    }
};
class SquareFactory : public Factory {
public:
    Shape* get() override
    {
        return new Square();
    }
};
class CircleFactory : public Factory {
public:
    Shape* get() override
    {
        return new Circle();
    }
};



int main() {

    Factory* fac1 = new RectangleFactory();  // 长方形
    Shape* shape1 = fac1->get();
    shape1->draw();

    Factory* fac2 = new SquareFactory();  // 正方形
    Shape* shape2 = fac2->get();
    shape2->draw();

    Factory* fac3 = new CircleFactory();  // 圆形
    Shape* shape3 = fac3->get();
    shape3->draw();

    // 注意释放对象。 // 这里可以采用智能指针管理对象的创建和销毁，具体在工厂模式中操作
    delete shape1;
    delete shape2;
    delete shape3;
}

扩展：增加一个triangle类，和triangleFactory类即可。

---

简单工厂模式：
它提供了一种创建对象的最佳方式。在工厂模式中，我们在创建对象时不会对客户端暴露创建逻辑，并且是通过使用一个共同的接口来指向新创建的对象。

步骤：

1. 创建一个接口: Shape
2. 创建实现接口的实体类: Rectangle /Square /Circle
3. 创建一个工厂，生成基于给定信息的实体类的对象。ShapeFactory
4. 使用该工厂，通过传递类型信息来获取实体类的对象。

class Shape {
public:
    virtual void draw() = 0 ;
};

class Rectangle : public Shape {
public:
    void draw()override {
        printf("矩形\n");
    }
};
class Square :public Shape {
public:
    void draw()override {
        printf("正方形\n");
    }
};
class Circle : public Shape {
public:
    void draw()override {
        printf("圆形\n");
    }
};

class ShapeFactory {
public:
    //使用 getShape 方法获取形状类型的对象
    Shape* getShape(string shapeType) {
        if (shapeType == "CIRCLE" ) {
            return new Circle();
        }
        else if (shapeType == "RECTANGLE" ) {
            return new Rectangle();
        }
        else if (shapeType == "SQUARE" ) {
            return new Square();
        }
    }
};


int main(){
    // 创建工厂
    ShapeFactory shapeFactory;

    //工厂通过参数生产产品
    Shape* shape1 = shapeFactory.getShape("CIRCLE");
    shape1->draw();

    Shape* shape2 = shapeFactory.getShape("RECTANGLE");
    shape2->draw();

    Shape* shape3 = shapeFactory.getShape("SQUARE");
    shape3->draw();

	// 注意释放对象。 // 这里可以采用智能指针管理对象的创建和销毁，具体在工厂模式中操作
    delete shape1;
    delete shape2;
    delete shape3;
}

扩展：增加一个triangle类，需要修改ShapeFactory 工厂内部逻辑，增加对应实例选项。

---

抽象工厂
抽象工厂模式（Abstract Factory Pattern）是围绕一个超级工厂创建其他工厂。该超级工厂又称为其他工厂的工厂。这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式。

在抽象工厂模式中，接口是负责创建一个相关对象的工厂，不需要显式指定它们的类。每个生成的工厂都能按照工厂模式提供对象。

先创建工厂，在使用特定工厂创建实体。

步骤：

1. 为形状创建一个接口。及创建实现接口的实体类。 shape：{Rectangle /Square /Circle}
2. 为颜色创建一个接口。及创建实现接口的实体类。color：{red / green / blue}
3. 为 Color 和 Shape 对象创建抽象类来获取工厂。
4. 创建扩展了 AbstractFactory 的工厂类，基于给定的信息生成实体类的对象。
5. 创建一个工厂创造器/生成器类，通过传递形状或颜色信息来获取工厂。
6. 使用 FactoryProducer 来获取 AbstractFactory，通过传递类型信息来获取实体类的对象。

// 形状的实体
class Rectangle : public Shape {
public:
    void draw()override {
        printf("矩形\n");
    }
};
class Square :public Shape {
public:
    void draw()override {
        printf("正方形\n");
    }
};
class Circle : public Shape {
public:
    void draw()override {
        printf("圆形\n");
    }
};

// 颜色的实体
class Red : public Color {
public:
    void draw()override {
        printf("Red\n");
    }
};
class Green :public Color {
public:
    void draw()override {
        printf("Green\n");
    }
};
class Blue : public Color {
public:
    void draw()override {
        printf("Blue\n");
    }
};


// ------- 工厂
 

// 抽象工厂：用于创建颜色工厂或形状工厂
class FactoryProducer {
public:
    AbstractFactory* getFactory(string choice) {
        if (choice == "SHAPE") {
            return new ShapeFactory();
        }
        else if (choice == "COLOR") {
            return new ColorFactory();
        }
        return nullptr;
    }
};

// 形状工厂：用于创建形状实体
class ShapeFactory : public  AbstractFactory {
public:
    //使用 getShape 方法获取形状类型的对象
    Shape* getShape(string shapeType) override
    {
        if (shapeType == "CIRCLE") {
            return new Circle();
        }
        else if (shapeType == "RECTANGLE") {
            return new Rectangle();
        }
        else if (shapeType == "SQUARE") {
            return new Square();
        }
    }
    Color* getColor(string color) override
    {
        return nullptr; // 啥都不干
    }
};

// 颜色工厂：用于创建颜色实体
class ColorFactory : public  AbstractFactory {
public:
    //使用 getShape 方法获取形状类型的对象
    Color* getColor(string colorType) override
    {
        if (colorType == "RED") {
            return new Red();
        }
        else if (colorType == "GREEN") {
            return new Green();
        }
        else if (colorType == "BLUE") {
            return new Blue();
        }
    }
    Shape* getShape(string shape) override
    {
        return nullptr; // 啥都不干
    }
};





int main(){
    // 通过抽象工厂生成器，生成形状工厂
    AbstractFactory* ffac_shape = FactoryProducer().getFactory("SHAPE");;

    //工厂通过参数生产产品
    Shape* shape1 = ffac_shape->getShape("CIRCLE");
    shape1->draw();

    Shape* shape2 = ffac_shape->getShape("RECTANGLE");
    shape2->draw();

    Shape* shape3 = ffac_shape->getShape("SQUARE");
    shape3->draw();

    delete shape1;
    delete shape2;
    delete shape3;


    // 通过抽象工厂生成器，生成颜色工厂
    AbstractFactory* ffac_color = FactoryProducer().getFactory("COLOR");;

    //工厂通过参数生产产品
    Color* color1 = ffac_color->getColor("RED");
    color1->draw();

    Color* color2 = ffac_color->getColor("GREEN");
    color2->draw();

    Color* color3 = ffac_color->getColor("BLUE");
    color3->draw();

    delete color1;
    delete color2;
    delete color3;
}