工厂模式

2017-09-11  本文已影响16人  第八区

工厂模式分三类:

简单工厂不属于设计模式,因为其违背了设计模式的开闭原则,后面会有介绍。

工厂方法

factory_function.png

相关元素:

示例

抽象产品

class Car {
public:
    virtual void printInfo()=0;
};

具体产品

class BenChi :public Car {
public:
    void printInfo() {
        cout << "BenChi" << endl;
    }
};

class Aodi :public Car {
public:
    void printInfo() {
        cout << "Aodi" << endl;
    }
};

抽象工厂

class AbstractFactory {
public:
    virtual Car * createCar() = 0;
};

具体工厂:

class FactoryBenchi :public AbstractFactory {
public:
    Car * createCar() {
        return new BenChi();
    };
};

class FactoryAodi :public AbstractFactory {
public:
    Car * createCar() {
        return new Aodi();
    };
};

这是一个比较标准的工厂方法设计模式。车可以生产车,那具体的奥迪车工厂可以生产奥迪车,奔驰车工厂可以生产奔驰的车。当需要生产法拉利的车时,我们只需要实现一个法拉利的产品,然后实现一个法拉利的工厂即可,而不需要修改之前的代码。这符合开闭原则。

简单工厂

factory_simple.png

这是工厂模式的简单实现方式,包含元素

示例

这里抽象产品和抽象方法和前面一样。
工厂类

class SimpleFactory{
public:
    static Car * createCar(const string type) {
        if (type == string("benchi")) {
            return new BenChi();
        }
        else if (type == string("aodi")) {
            return new Aodi();
        }
        else {
            return NULL;
        }
    }
};

我们看到工厂类就是一个单独的类,通过传入的参数来区分返回什么样的产品。比如:当需要生产法拉利时,我们需要修改工厂类的方法。这不符合开闭原则,所以它不属于设计模式。只是工厂模式的一个变相简单的实现。

抽象工厂

前面说到工厂方法只能生产一个类型的产品。当我们需要生产一系列的产品,比如:我们需要奥迪的发动机,那么肯定也是在奥迪的工厂生产,那么这里就可以使用抽象工厂设计模式

元素

示例

这里我们再Car的基础上在增加一个产品Engine

class Engine {
public:
    virtual void printName() = 0;
};

实现类:

class EngineBenchi :public Engine {
public:
    void printName() {
        cout << "benchi engine" << endl;
    }
};

class EngineAodi :public Engine {
public:
    void printName() {
        cout << "aodi engine" << endl;
    }
};

抽象类也需要进行修改:

class AbstractFactory {
public:
    virtual Car * createCar() = 0;
    virtual Engine * createEngine() = 0;
};

实现类:

class FactoryBenchi :public AbstractFactory {
public:
    Car * createCar() {
        return new BenChi();
    };
    Engine * createEngine() {
        return new EngineBenchi();
    }
};

class FactoryAodi :public AbstractFactory {
public:
    Car * createCar() {
        return new Aodi();
    };
    Engine * createEngine() {
        return new EngineAodi();
    }
};

测试代码:

int main()
{
    AbstractFactory *factory = NULL;
    Car* car = NULL;
    Engine* engine = NULL;
    factory=new FactoryBenchi();
    car = factory->createCar();
    car->printInfo();
    engine = factory->createEngine();
    engine->printName();
    delete factory;
    delete car;
    delete engine;
    factory = new FactoryAodi();
    car = factory->createCar();
    car->printInfo();
    engine = factory->createEngine();
    engine->printName();
    delete factory;
    delete car;
    delete engine;
    return 0;
}

这样我们就完成的奥迪工厂既可以生产车,也可以生产发动机。同样我们也发现了他的缺点。当需要再添加一种商品时,发现需要修改很多地方。抽象工厂需要修改,同时所有的实现类都需要发生修改。产品的扩展很复杂。优点当然也明显,它是的产品族的多个产品设计在一起工作时,它能保证使用的是同一个产品族的产品。

上一篇 下一篇

猜你喜欢

热点阅读