设计模式-工厂模式

简单工厂模式

属于设计模式类型中的创建型模式，所谓创建型模式是指：在创建对象的同时隐藏创建逻辑的方式，而不是用new运算符直接实例化对象。这使得程序在判断针对某个给定实例需要创建哪些对象时更加的灵活。

工厂模式是我们常用的实例化对象模式了，是用工厂方法代替new操作的一种模式。我们经常用户new来创建对象，例如，B b = new B()。

为什么需要工厂模式？面向对象的封装和分派告诉我们，尽量将长的代码分派“切割”成每一段，将每段再“封装”起来（减少段与段之间的耦合联系性），这样就会将风险分散，以后如果需要修改，只要更改每段，不会再发生牵一动百的事情。

简单工厂模式将创建实例的工作和使用实例的工作分开，将对象的创建交给专门的工厂负责。缺点在于工厂类不够灵活，增加新的产品需要修改工厂类的判定逻辑。

#include "stdafx.h"

#include <iostream>

using namespace std;

//产品基类

class Book

{

public:

    virtual void read() = 0;//抽象基类

};

 

//书籍1

class Book1: public Book

{

public:

    void read()

    {

        cout << "This book is c++.\n";

    }

};

 

//书籍2

class Book2 : public Book

{

public:

    void read()

    {

        cout << "This book is java.\n";

    }

};

 

//工厂类

class BookFactory

{

public:

    static Book* createBook(const std::string& type)

    {

        Book* pBook = NULL;

        if (type == "c++")

        {

            pBook = new Book1();

        }

        else if (type == "java")

        {

            pBook = new Book2();

        }

 

        return pBook;

    }

};

 

int main(int argc, _TCHAR* argv[])

{

    BookFactory::createBook("c++")->read();

    BookFactory::createBook("java")->read();

    return 0;

}

工厂方法模式

前面提到的简单工厂模式中，工厂类集成了所有实例的创建逻辑，一旦这个工厂不能工作，整个系统会收到影响，也违背了“开放-关闭原则”，一旦添加新的产品就不得不修改工厂类的逻辑，这样会造成工厂逻辑过于复杂，简单工厂模式使用了静态工厂的方法，静态的方法不能被继承和重写，会造成工厂角色无法形成基于继承的等级结构。

工厂方法模式，工厂父类负责定义创建对象的公共接口，而子类则负责生成具体的对象。

将类的实例化延迟到工厂的子类中完成，即由子类决定实例化哪一个类。

 

// test.cpp : 定义控制台应用程序的入口点。

//

 

#include "stdafx.h"

#include <iostream>

using namespace std;

//产品基类

class Book

{

public:

    virtual void read() = 0;//抽象基类

};

 

//书籍1

class Book1: public Book

{

public:

    void read()

    {

        cout << "This book is c++.\n";

    }

};

 

//书籍2

class Book2 : public Book

{

public:

    void read()

    {

        cout << "This book is java.\n";

    }

};

 

//工厂基类

class BookFactory

{

public:

    virtual Book* createBook() = 0;//抽象基类

};

 

class BookFactory1: public BookFactory

{

public:

    Book* createBook()

    {

        return new Book1();

    }

};

 

class BookFactory2: public BookFactory

{

public:

    Book* createBook()

    {

        return new Book2();

    }

};

 

 

int main(int argc, _TCHAR* argv[])

{

    BookFactory* bookFactory1 = new BookFactory1();

    bookFactory1->createBook()->read();

 

    BookFactory* bookFactory2 = new BookFactory2();

    bookFactory2->createBook()->read();

    return 0;

}

 

 

抽象工厂模式

抽象工厂模式相对于工厂方法模式来说，就是工厂方法模式是针对一个产品系列的，而抽象工厂模式是针对多个产品系列的，即工厂方法模式是一个产品系列一个工厂类，而抽象工厂模式是多个产品系列一个工厂类。

 

#include "stdafx.h"

#include <iostream>

using namespace std;

//产品基类

class Book

{

public:

    virtual void read() = 0;//抽象基类

};

 

class Food

{

public:

    virtual void eat() = 0; //抽象基类

};

 

//书籍1

class Book1: public Book

{

public:

    void read()

    {

        cout << "This shop is tm.\n";

    }

};

 

class Book2 : public Book

{

public:

    void read()

    {

        cout << "This shop is jd.\n";

    }

};

 

class Food1 : public Food

{

public:

    void eat()

    {

        cout << "This shop is tm.\n";

    }

};

 

class Food2 : public Food

{

public:

    void eat()

    {

        cout << "This shop is jd.\n";

    }

};

 

//工厂基类

class Factory

{

public:

    virtual Book* createBook() = 0;//抽象基类

    virtual Food* createFood() = 0; //抽象基类

};

 

//天猫

class Factory1 : public Factory

{

public:

    Book* createBook()

    {

        return new Book1();

    }

 

    Food* createFood()

    {

        return new Food1();

    }

 

};

 

//京东

class Factory2 : public Factory

{

public:

    Book* createBook()

    {

        return new Book2();

    }

 

    Food* createFood()

    {

        return new Food1();

    }

};

 

 

int main(int argc, _TCHAR* argv[])

{

    Factory* pFactory1 = new Factory1();

    pFactory1->createBook()->read();

 

    Factory* pFactory2 = new Factory2();

    pFactory2->createBook()->read();

    return 0;

}