工厂模式(C++)

工厂模式是我们最常用的实例化对象模式了，是用工厂方法代替new操作的一种模式。工厂模式就相当于创建实例对象的new，我们经常要根据类Class生成实例对象，如A a=new A() 工厂模式也是用来创建实例对象的，所以以后new时就要多个心眼，是否可以考虑使用工厂模式，虽然这样做，可能多做一些工作，但会给你系统带来更大的可扩展性和尽量少的修改量。<依旧来自百度百科>

为什么要有工厂模式

---

当我们创建实例对象时,如果不仅仅做赋值这样简单的事情,而是有一大段逻辑,那这个时候我们要将所有的初始化逻辑都写在构造函数中吗? 只能说,这会让你的代码变得很难看

面向对象的基本思想封装告诉我们,我们尽量将长的代码进行"切割",再将每一个小逻辑都"封装"起来,这样可以降低耦合度,修改的时候也可以直奔错误段落

在工厂模式中,我们将创建实例和使用实例的工作分开,使构造函数的负担减轻

工厂模式的分类

---

• 简单工厂模式

• 工厂方法模式

• 抽象工厂模式

简单工厂模式

---

特点: 需要在工厂类中作出判断,在创建产品的时候,指定响应产品创造

缺点: 每次新增一个类时,都需要改变工厂函数,破坏了封装性

背景1: 现在有一家电脑生产厂家,他们现在只有一个工厂,当前可以生产处 联想的台式机 和 戴尔的台式机

enum TYPE{LENOVO,DELL};

// 生产厂家
class Desktop_Computer
{
public:
    virtual void Product() = 0;
};

// 生产联想台式机
class Lenovo_Desktop : public Desktop_Computer
{
public:
    void Product()
    {
        cout<<"Lenovo Desktop computer..."<<endl;
    }
};

// 生产戴尔台式机
class Dell_Desktop : public Desktop_Computer
{
public:
    void Product()
    {
        cout<<"Dell Desktop computer..."<<endl;
    }
};

// 唯一的一个工厂
class Factory
{
public:
    Desktop_Computer* Product_Computer(TYPE type)
    {
        if(type == LENOVO)
        {
            return new Lenovo_Desktop();
        }
        else if(type == DELL)
        {
            return new Dell_Desktop();
        }
        return NULL;
    }
};

int main()
{
    Factory f;
    Desktop_Computer* lc = f.Product_Computer(LENOVO);
    lc->Product();

    Desktop_Computer* dc = f.Product_Computer(DELL);
    dc->Product();
    return 0;
}

 

开放封闭原则：软件实体（类、模块、函数）可以扩展，但是不可修改。

如果生产厂家需要新增一个产品,那么工厂函数Factory就需要跟着改变,所以上面的工厂模式违背了开放封闭原则;

工厂方法模式

---

特点: 定义一个用于创建对象的接口，让子类决定实例化哪一个类。

缺点: 每增加一个新的产品,就需要增加一个新的工厂

背景2: 随着时代的发展,电脑慢慢的供不应求,于是这个生产厂家为了提高生产效率,开设了第二个工厂

一个工厂专门用来生产联想的台式机

一个工厂专门用来生产戴尔的台式机

这个时候如果你想要哪个电脑,直接找对应的工厂要就好了

 

// 生产厂家
class Desktop_Computer
{
public:
    virtual void Product() = 0;
};

// 联想台式机
class Lenovo_Desktop : public Desktop_Computer
{
public:
    void Product()
    {
        cout<<"Lenovo Desktop computer..."<<endl;
    }
};

// 戴尔台式机
class Dell_Desktop : public Desktop_Computer
{
public:
    void Product()
    {
        cout<<"Dell Desktop computer..."<<endl;
    }
};

class Factory
{
public:
    virtual Desktop_Computer* Product_Computer() = 0;
};

// 联想台式机制造工厂
class Lenovo_Factory : public Factory
{
public:
    Desktop_Computer* Product_Computer()
    {
        return new Lenovo_Desktop();
    }
};

// 戴尔台式机制造工厂
class Dell_Factory : public Factory
{
public:
    Desktop_Computer* Product_Computer()
    {
        return new Dell_Desktop();
    }
};

int main()
{
    Lenovo_Factory lf;
    Desktop_Computer* lc = lf.Product_Computer();
    lc->Product();

    Dell_Factory df;
    Desktop_Computer* dc = df.Product_Computer();
    dc->Product();
    return 0;
}

 

工厂方法模式和抽象工厂模式区别在于需要创建对象的复杂程度上。如果我们创建对象的方法变得复杂了,可以将Factory变成抽象类,将共同部分封装在抽象类中,不同部分使用子类实现

抽象工厂模式

---

特点: 提供一个创建一系列相关或相互依赖对象的接口,而无需指定它们具体的类。

背景3: 随着人们的需求,台式机已经不能满足用户了,用户们更希望有一个随身携带的便捷式电脑,于是这个生产厂家决定生产笔记本电脑,还是联想和戴尔两个牌子

工厂1: 生产联想的台式机和笔记本电脑

工厂2: 生产戴尔的台式机和笔记本电脑

// 生产台式机
class Desktop_Computer
{
public:
    virtual void Product() = 0;
};

// 联想台式机
class Lenovo_Desktop : public Desktop_Computer
{
public:
    void Product()
    {
        cout<<"Lenovo Desktop computer..."<<endl;
    }
};

// 戴尔台式机
class Dell_Desktop : public Desktop_Computer
{
public:
    void Product()
    {
        cout<<"Dell Desktop computer..."<<endl;
    }
};

// 生产笔记本电脑
class Notebook_Computer
{
public:
    virtual void Product() = 0;
};

// 联想笔记本
class Lenovo_Notebook : public Notebook_Computer
{
public:
    void Product()
    {
        cout<<"Lenovo Notebook computer..."<<endl;
    }
};

// 戴尔笔记本
class Dell_Nodebook : public Notebook_Computer
{
public:
    void Product()
    {
        cout<<"Dell Notebook computer..."<<endl;
    }
};

// 工厂类
class Factory
{
public:
    virtual Desktop_Computer* Product_Desktop() = 0;
    virtual Notebook_Computer* Product_Notebook() = 0;
};

// 联想工厂,生产联想的台式机和笔记本电脑
class Lenovo_Factory : public Factory
{
public:
    Desktop_Computer* Product_Desktop()
    {
        return new Lenovo_Desktop();
    }
    Notebook_Computer* Product_Notebook()
    {
        return new Lenovo_Notebook();
    }
};

// 戴尔工厂,生产戴尔的台式机和笔记本电脑
class Dell_Factory : public Factory
{
public:
    Desktop_Computer* Product_Desktop()
    {
        return new Dell_Desktop();
    }
    Notebook_Computer* Product_Notebook()
    {
        return new Dell_Nodebook();
    }
};

int main()
{
    Lenovo_Factory lf;
    Desktop_Computer* ld = lf.Product_Desktop();
    Notebook_Computer* ln = lf.Product_Notebook();
    ld->Product();
    ln->Product();

    Dell_Factory df;
    Desktop_Computer* dd = df.Product_Desktop();
    Notebook_Computer* dn = df.Product_Notebook();
    dd->Product();
    dn->Product();
    return 0;
}

 

看了上面的例子,心里莫名感到奇怪,为什么不可以写多个工厂来分别生产呢?

抽象工厂还有一个关键的要点,是因为Factory中Desktop_Computer和Notebook_Conputer有着一定的联系,所以才将这两个方法捆绑在一个类中,这是这个工厂类的本身特征