GoF设计模式——工厂模式

文章目录

• • 🌳概念
  • 🌳 简单工厂模式
  • 🌳 工厂方法模式
  • 🌳 抽象工厂模式

🌳概念

为了提高内聚(Cohesion)和松耦合(Coupling),我们经常会抽象出一些类的公共 接口以形成抽象基类或者接口。

这样我们可以通过声明一个指向基类的指针来指向实际的子 类实现,达到了多态的目的。

工厂模式属于创建型模式，它提供了一种创建对象的最佳方式。

通过定义创建对象的接口，封装了对象的创建；使得类的实例化工作延迟到了子类中。

工厂模式的实现方式可分为简单工厂模式、工厂方法模式、抽象工厂模式。

🌳 简单工厂模式

🍞具体的情形：一个机器视觉光源生产商，生产的产品有条形光、同轴光、环形光。

🍔简单工厂模式结构组成：

1. 工厂类：lightFoctory,工厂模式的核心类，会定义一个用于创建指定的具体实例对象的接口。
   

   
   

2. 抽象产品类：Light,是具体产品类的继承的父类或实现的接口。
   

   
   

3. 具体产品类：BarLight、RingLight、CoaxialLight工厂类所创建的对象就是此具体产品实例。
   

   
   

🍟 简单工厂的缺点：
扩展性差，新增产品的时候，需要去修改工厂类。

违法了开闭法则（OCP）

#include
enum LIGHTTYPE {BAR,RING,COAXIAL};

class Light
{
public:
    Light(){};
    virtual ~Light(){};
    virtual void work() = 0;
};

class BarLight : public Light
{
    public:
    void work() {qDebug()<<"BarLight!"<<'\t';}
};

class RingLight:public Light
{
    public:
    void work() {qDebug()<<"RingLight!"<<'\t';}
};

class CoaxialLight:public Light
{
    public:
    void work() {qDebug()<<"CoaxialLight!"<<'\t';}
};

class LightFoctory
{
    public:
    Light* product(LIGHTTYPE type)
    {
        switch(type)
        {
            case BAR:
                return new BarLight();
                break;
            case RING:
                return new RingLight();
                break;
            case COAXIAL:
                return new CoaxialLight();
                break;
            default:break;
        }

    }
};

int main(int argc, char *argv[])
{
    LightFoctory factory;
    Light* barLight = factory.product(BAR);
    barLight->work();
    Light* ringLight = factory.product(RING);
    ringLight->work();
    Light* coaxialLight = factory.product(COAXIAL);
    coaxialLight->work();
    delete barLight;
    delete ringLight;
    delete coaxialLight;
    return 0;
}

🧀运行结果：

🌳 工厂方法模式

🍞具体情形：
机器视觉行业火爆，需要大量生产每种类型的光源，则要针对不同类型的光源开设独立的生产线，那么每个生产线就只能生产同类型的光源。

🍔工厂方法模式的结构组成：

1. 抽象工厂类：LightFactoryBase，工厂方法模式的核心类，提供创建具体产品的接口，由具体工厂类实现。
   

   
   

2. 具体工厂类：CoaxialLightFoctory、RingLightFoctory、BarLightFoctory，继承于抽象工厂，实现创建对应具体产品对象的方式。
   

   
   

3. 抽象产品类：Light，它是具体产品继承的父类（基类）。
   

   
   

4. 具体产品类：BarLight、RingLight、CoaxialLight具体工厂所创建的对象，就是此类。
   

   
   

🍟 工厂方法缺点：
每增加一种产品，就需要增加一个对象的工厂。

相比简单工厂模式而言，工厂方法模式需要更多的类定义。

class Light
{
public:
    Light(){};
    virtual ~Light(){};
    virtual void work() = 0;
};

class BarLight : public Light
{
    public:
    void work() {qDebug()<<"BarLight!"<<'\t';}
};

class RingLight:public Light
{
    public:
    void work() {qDebug()<<"RingLight!"<<'\t';}
};

class CoaxialLight:public Light
{
    public:
    void work() {qDebug()<<"CoaxialLight!"<<'\t';}
};
class LightFactoryBase
{
    public:
    virtual Light * product() = 0;
};

class CoaxialLightFoctory:public LightFactoryBase
{
    public:
    Light * product()
    {
        return new CoaxialLight();
    }
};

class RingLightFoctory:public LightFactoryBase
{
    public:
    Light * product()
    {
        return new RingLight();
    }
};

class BarLightFoctory:public LightFactoryBase
{
    public:
    Light * product()
    {
        return new BarLight();
    }
};

int main(int argc, char *argv[])
{
    CoaxialLightFoctory coaxialLightFactory;
    Light* barLight = coaxialLightFactory.product();
    barLight->work();

    RingLightFoctory ringLightFoctory;
    Light* ringLight = ringLightFoctory.product();
    ringLight->work();

    BarLightFoctory barLightFoctory;
    Light* coaxialLight = barLightFoctory.product();
    coaxialLight->work();
    delete barLight;
    delete ringLight;
    delete coaxialLight;
    return 0;
}

🧀运行结果：

🌳 抽象工厂模式

🍞具体情形：
光源生产商调研发现家用光源也很赚钱，现在投资两个厂房，一个生产机器视觉和家用条形光，一个生产机器视觉和家用环形光。

🍔抽象工厂模式结构组成:

1. 抽象工厂类：LightFoctoryBase，工厂方法模式的核心类，提供创建具体产品的接口，由具体工厂类实现。
   

   
   

2. 具体工厂类：BarLightFoctory、RingLightFoctory，继承于抽象工厂，实现创建对应具体产品对象的方式。
   

   
   

3. 抽象产品类：LightFoctory、MachineVisionLight它是具体产品继承的父类（基类）。
   

   
   

4. 具体产品类：HouseholdBarLight，HouseholdRingLight、MachineVisionBarLight、RingLightFoctory，具体工厂所创建的对象，就是此类。
   

   
   

🍟 工厂方法模式缺点：
同工厂方法模式一样，新增产品时，都需要增加一个对应的产品的具体工厂类。

    class HouseholdLight
    {
        public:
            HouseholdLight(){};
            virtual ~HouseholdLight(){};
            virtual void work() = 0;
    };

    class HouseholdBarLight : public HouseholdLight
    {
        public:
        void work() {qDebug()<<"HouseholdBarLight!"<<'\t';}
    };

    class HouseholdRingLight:public HouseholdLight
    {
        public:
        void work() {qDebug()<<"HouseholdRingLight!"<<'\t';}
    };


    /
    class MachineVisionLight
    {
        public:
            MachineVisionLight(){};
            virtual ~MachineVisionLight(){};
            virtual void work() = 0;
    };

    class MachineVisionBarLight : public MachineVisionLight
    {
        public:
        void work() {qDebug()<<"MachineVisionBarLight!"<<'\t';}
    };

    class MachineVisionRingLight:public MachineVisionLight
    {
        public:
        void work() {qDebug()<<"MachineVisionRingLight!"<<'\t';}
    };

    //

    class LightFactoryBase
    {
        public:
        virtual MachineVisionLight * productMachineVisionLight() = 0;
        virtual HouseholdLight * productHouseholdLight() = 0;

    };


    class RingLightFoctory:public LightFactoryBase
    {
        public:
            HouseholdLight * productHouseholdLight()
            {
                return new HouseholdRingLight();
            }

            MachineVisionLight * productMachineVisionLight()
            {
                return new MachineVisionRingLight();
            }

    };

    class BarLightFoctory:public LightFactoryBase
    {
        public:
        HouseholdLight * productHouseholdLight()
        {
            return new HouseholdBarLight();
        }

        MachineVisionLight * productMachineVisionLight()
        {
            return new MachineVisionBarLight();
        }
    };

int main(int argc, char *argv[])
{
  	BarLightFoctory barLightFoctory;
    RingLightFoctory ringLightFoctory;

    HouseholdLight *houseBarLight = nullptr;
    MachineVisionLight *mvBarLight = nullptr;
    houseBarLight = barLightFoctory.productHouseholdLight();
    mvBarLight = barLightFoctory.productMachineVisionLight();
    houseBarLight->work();
    mvBarLight->work();

    HouseholdLight *houseRingLight = nullptr;
    MachineVisionLight *mvRingLight = nullptr;
    houseRingLight = ringLightFoctory.productHouseholdLight();
    mvRingLight = ringLightFoctory.productMachineVisionLight();
    houseRingLight->work();
    mvRingLight->work();

    delete houseBarLight;
    delete mvBarLight;
    delete houseRingLight;
    delete mvRingLight;
    
    return 0;
}

🧀运行结果;