设计模式 --> （1）工厂模式

时间：2015-10-26 18:14:18 阅读：123 评论：0 收藏：0 [点我收藏+]

标签：

工厂模式

　　工厂模式属于创建型模式，大致可以分为三类，简单工厂模式、工厂方法模式、抽象工厂模式。

简单工厂模式

　　简单工厂模式，它的主要特点是需要在工厂类中做判断，从而创造相应的产品。当增加新的产品时，就需要修改工厂类。

例如：有一家生产处理器核的厂家，它只有一个工厂，能够生产两种型号的处理器核。客户需要什么样的处理器核，一定要显示地告诉生产工厂。下面给出一种实现方案。

// 简单工厂模式
#include <iostream>
using namespace std;

enum CTYPE {PRODUCT_A, PRODUCT_B}; // 抽象产品
class AbstractProduct
{
public:
    virtual void getProductsName() = 0;
};

// 具体产品1
class ConcreteProduct1: public AbstractProduct
{
public:
    void  getProductsName()  { cout << "ConcreteProduct1" << endl; }
};

// 具体产品2
class ConcreteProduct2: public AbstractProduct
{
public:
    void  getProductsName()  { cout << "ConcreteProduct2" << endl; }
};

// 具体的工厂（没有抽象工厂）,，可以生产两种产品，在内部判断 
class ConcreteFactory
{
public:
    AbstractProduct* getProductObject(enum CTYPE ctype)
    {
        if(ctype == PRODUCT_A)
        {
            return new ConcreteProduct1();
        }
        else if(ctype == PRODUCT_B)
        {
            return new ConcreteProduct2();
        }
        else
        {
            return 0;
        }
    }
};

int main()
{
    ConcreteFactory f;
    AbstractProduct* p1 = f.getProductObject(PRODUCT_A);
    AbstractProduct* p2 = f.getProductObject(PRODUCT_B);
    p1->getProductsName();
    p2->getProductsName();
    delete p1;
    delete p2;
    return 0;
}

这样设计的主要缺点就是要增加新的产品时，就需要修改工厂类。这就违反了开放封闭原则：软件实体（类、模块、函数）可以扩展，但是不可修改。于是，工厂方法模式出现了。

工厂方法模式

　　工厂方法模式，是指定义一个用于创建对象的接口，让子类决定实例化哪一个类。Factory Method使一个类的实例化延迟到其子类。

这家生产处理器核的产家赚了不少钱，于是决定再开设一个工厂专门用来生产B型号的单核，而原来的工厂专门用来生产A型号的单核。这时，客户要做的是找好工厂，比如要A型号的核，就找A工厂要；否则找B工厂要，不再需要告诉工厂具体要什么型号的处理器核了。下面给出一个实现方案。

#include <iostream>
using namespace std;

//普通工厂模式

//抽象产品
class AbstractProduct
{
public:
    virtual void getProductName() = 0;
};

//具体产品1
class ConcreteProduct1: public AbstractProduct
{
public:
    void getProductName() { cout << "ConcreteProduct1" << endl; }
};

//具体产品2
class ConcreteProduct2: public AbstractProduct
{
public:
    void getProductName() { cout << "ConcreteProduct2" << endl; }
};

//抽象工厂
class AbstractFactory
{
public:
    virtual AbstractProduct* getProduct() = 0;
};

//具体工厂1
class ConcreteFactory1: public AbstractFactory
{
public:
    AbstractProduct* getProduct()
    {
        return new ConcreteProduct1();
    }
};

//具体工厂2
class ConcreteFactory2: public AbstractFactory
{
public:
    AbstractProduct* getProduct()
    {
        return new ConcreteProduct2();
    }
};

int main()
{
    AbstractFactory* f1 = new ConcreteFactory1();
    AbstractFactory* f2 = new ConcreteFactory2();
    f1->getProduct()->getProductName();
    f2->getProduct()->getProductName();
    delete f1, f2;
    return 0;
}

工厂方法模式也有缺点，每增加一种产品，就需要增加一个对象的工厂。如果这家公司发展迅速，推出了很多新的产品，那么就要开设相应的新工厂。在C++实现中，就是要定义一个个的工厂类。显然，相比简单工厂模式，工厂方法模式需要更多的类定义。

抽象工厂模式

　　抽象工厂模式，为提供一个创建一系列相关或相互依赖对象的接口，而需指定它们具体的类。

这家公司的技术不断进步，不仅可以生产单核处理器，也能生产多核处理器。现在简单工厂模式和工厂方法模式都鞭长莫及。抽象工厂模式登场了。这家公司还是开设两个工厂，一个专门用来生产A型号的单核多核处理器，而另一个工厂专门用来生产B型号的单核多核处理器，下面给出实现的代码。

#include <iostream>
using namespace std;

// 抽象工厂模式 

// 抽象产品A
class AbstractProductA
{
public:
    virtual void getProductName() = 0;
};

// 具体产品A1
class ConcreteProductA1: public AbstractProductA
{
public:
    void getProductName() { cout << "ConcreteProductA1" << endl; }
};

// 具体产品A2
class ConcreteProductA2: public AbstractProductA
{
public:
    void getProductName() { cout << "ConcreteProductA2" << endl; }
};

// 抽象产品B
class AbstractProductB
{
public:
    virtual void getProductName() = 0;
};

// 具体产品B1
class ConcreteProductB1: public AbstractProductB
{
public:
    void getProductName() { cout << "ConcreteProductB1" << endl; }
};

// 具体产品B2
class ConcreteProductB2: public AbstractProductB
{
public:
    void getProductName() { cout << "ConcreteProductB2" << endl; }
};

// 抽象工厂
class AbstractFactory
{
public:
    virtual AbstractProductA* getProductA() = 0;
    virtual AbstractProductB* getProductB() = 0;
};

// 具体工厂1
class ConcreteFactory1: public AbstractFactory
{
    AbstractProductA* getProductA()
    {
        return new ConcreteProductA1;
    }

    AbstractProductB* getProductB()
    {
        return new ConcreteProductB1;
    }
};
 
// 具体工厂2
class ConcreteFactory2: public AbstractFactory
{
    AbstractProductA* getProductA()
    {
        return new ConcreteProductA2;
    }

    AbstractProductB* getProductB()
    {
        return new ConcreteProductB2;
    }
};

int main()
{
    AbstractFactory *f1 = new ConcreteFactory1();
    AbstractFactory *f2 = new ConcreteFactory2();
    f1->getProductA()->getProductName();
    f1->getProductB()->getProductName();
    f2->getProductA()->getProductName();
    f2->getProductB()->getProductName();
    delete f1, f2;
    return 0;
}

至此，三种模式介绍完毕。

设计模式 --> （1）工厂模式

标签：

原文地址：http://www.cnblogs.com/jeakeven/p/4911671.html

踩

(0)

评论一句话评论（0）

分享档案

更多>

2021年07月29日 (22)
2021年07月28日 (40)
2021年07月27日 (32)
2021年07月26日 (79)
2021年07月23日 (29)
2021年07月22日 (30)
2021年07月21日 (42)
2021年07月20日 (16)
2021年07月19日 (90)
2021年07月16日 (35)

周排行