工廠設計模式

下面例子中鼠標，鍵盤，耳麥爲產品，惠普，戴爾爲工廠。

簡單工廠模式

簡單工廠模式不是 23 種裏的一種，簡而言之，就是有一個專門生產某個產品的類。

比如下圖中的鼠標工廠，專業生產鼠標，給參數 0，生產戴爾鼠標，給參數 1，生產惠普鼠標。

#include "stdafx.h"
#include <iostream>
//簡單工廠模式是屬於創建型模式，又叫做靜態工廠方法(static Factory Method)模式，簡單工廠模式是由一個工廠對象決定創建出來哪一種產品類的實例.
//
//簡單工廠模式的實質是由一個工廠類根據傳入的參數，動態決定應該創建哪一類產品類(這些產品類繼承自一個父類或接口)的實例。打個比方
//
//假設有一個工廠，他能生產出A、B兩種產品。當客戶需要產品的時候一定要告訴共產是哪種產品，是A還是B。當新增加一種新產品的時候，那麼就要去修改工廠的類。

enum ProductType
{
    MOUSE_DELL = 1,
    MOUSE_HP
};

// 1. 共同類
class Mouse
{
public:
    virtual void show() = 0;
protected:
private:
};

// 2. 實現類
class Mouse_Dell:public Mouse
{
public:
    void show()
    {
        std::cout << "Product A provided!" << std::endl;
    }
private:

};

class Mouse_Hp:public Mouse
{
public:
    void show()
    {
        std::cout << "Product B provided!" << std::endl;
    }
private:

};

// 3.工廠類
class Factory
{
public:
    Mouse *Create(int i)
    {
        switch (i)
        {
        case MOUSE_DELL:
            return new Mouse_Dell;
            break;
        case MOUSE_HP:
            return new Mouse_Hp;
            break;
        default:
            break;
        }
        return 0;
    }
};

// 簡單工廠模式的缺點是當新增產品的時候就要去修改工廠的類，這就違反了開放封閉原則。(類、模塊、函數)可以擴展，但是不可以修改。
int _tmain(int argc, _TCHAR* argv[])
{
    Factory Fac;
    Fac.Create(MOUSE_DELL)->show();
    Fac.Create(MOUSE_HP)->show();
    getchar();
	return 0;
}

工廠模式

工廠模式也就是鼠標工廠是個父類，有生產鼠標這個接口。

戴爾鼠標工廠，惠普鼠標工廠繼承它，可以分別生產戴爾鼠標，惠普鼠標。

生產哪種鼠標不再由參數決定，而是創建鼠標工廠時，由戴爾鼠標工廠創建。

後續直接調用鼠標工廠.生產鼠標()即可

#include "stdafx.h"
#include <iostream>
//所謂工廠方法模式，是指定義一個用於創建對象的接口，讓子類決定實例化哪一個類。打個比方
//現在有A、B兩種產品，那麼就開兩個工廠。工廠A負責生產A產品，工廠B負責生產B種產品。
//這時候客戶不需要告訴工廠生產哪種產品了，只需要告訴工廠生產就可以了。

// 純虛類
class Product
{
public:
    virtual void show() = 0;
};
// Product實現類
class ProductA:public Product
{
public:
    void show(){
        std::cout << "Product A provided!" << std::endl;
    }
};

class ProductB:public Product
{
public:
    void show()
    {
        std::cout << "Product B provided!" << std::endl;
    }
};

// 工廠純虛類
class Factory
{
public:
    virtual Product* Create() = 0;
};
// 工廠實現類
class FactoryA :public Factory
{
public:
    Product* Create()
    {
        return new ProductA;
    }
};

class FactoryB : public Factory
{
public:
    Product* Create()
    {
        return new ProductB;
    }
};
int _tmain(int argc, _TCHAR* argv[])
{
    Factory *FacA = new FactoryA;
    Factory *FacB = new FactoryB;

    FacA->Create()->show();
    FacB->Create()->show();
    getchar();
	return 0;
}

抽象工廠模式

抽象工廠模式也就是不僅生產鼠標，同時生產鍵盤。

也就是 PC 廠商是個父類，有生產鼠標，生產鍵盤兩個接口。

戴爾工廠，惠普工廠繼承它，可以分別生產戴爾鼠標+戴爾鍵盤，和惠普鼠標+惠普鍵盤。

創建工廠時，由戴爾工廠創建。

後續工廠.生產鼠標()則生產戴爾鼠標，工廠.生產鍵盤()則生產戴爾鍵盤。

在抽象工廠模式中，假設我們需要增加一個工廠

假設我們增加華碩工廠，則我們需要增加華碩工廠，和戴爾工廠一樣，繼承 PC 廠商。

之後創建華碩鼠標，繼承鼠標類。創建華碩鍵盤，繼承鍵盤類即可。

在抽象工廠模式中，假設我們需要增加一個產品

假設我們增加耳麥這個產品，則首先我們需要增加耳麥這個父類，再加上戴爾耳麥，惠普耳麥這兩個子類。

之後在PC廠商這個父類中，增加生產耳麥的接口。最後在戴爾工廠，惠普工廠這兩個類中，分別實現生產戴爾耳麥，惠普耳麥的功能。 以上。

#include "stdafx.h"
#include<iostream>

// Mouse    -> Dell HP Asus
// KeyBoard -> DELL Cherry Logith

enum BrandType
{
    DELL,
    HP,
    ASUS,
    CHERRY,
    LOGITH
};

// 純虛產品類
class Mouse
{
public:
    virtual void Mouse_show() = 0;
};

class Keyboard
{
public:
    virtual void Keyboard_show() = 0;
};

// 產品實現類
class Mouse_Dell:public Mouse
{
public:
    void Mouse_show()
    {
        std::cout << "Dell Mouse Producted!" << std::endl;
    }
};

class Keyboard_DELL :public Keyboard
{
public:
    void Keyboard_show()
    {
        std::cout << "DELL Keyboard Producted!" << std::endl;
    }
};

class Mouse_HP :public Mouse
{
public:
    void Mouse_show()
    {
        std::cout << "HP Mouse Producted!" << std::endl;
    }
};

class Mouse_Asus :public Mouse
{
public:
    void Mouse_show()
    {
        std::cout << "HP Mouse Producted!" << std::endl;
    }
};

class Keyboard_Cherry :public Keyboard
{
public:
    void Keyboard_show()
    {
        std::cout << "Cherry Keyboard Producted!" << std::endl;
    }
};

class Keyboard_Logith :public Keyboard
{
public:
    void Keyboard_show()
    {
        std::cout << "Logith Keyboard Producted!" << std::endl;
    }
};

// 純虛工廠類
class Factory
{
public:
    virtual Mouse* ProductMouse(BrandType nType) = 0;
    virtual Keyboard* ProductKeyboard(BrandType nType) = 0;
};

// 實現工廠類
// 根據品牌生成產品
class Factory_Mouse :public Factory
{
public:
    Mouse* ProductMouse(BrandType nType) override
    {
        switch (nType)
        {
        case DELL:
            return new Mouse_Dell;
            break;
        case HP:
            return new Mouse_HP;
            break;
        case ASUS:
            return new Mouse_Asus;
        default:
            return NULL;
            break;
        }
    }
    Keyboard* ProductKeyboard(BrandType nType)
    {
        return NULL;
    }
};

// 根據品牌生成產品
class Factory_Keyboard :public Factory
{
public:
    Mouse* ProductMouse(BrandType nType) override
    {
        return NULL;
    }
    Keyboard* ProductKeyboard(BrandType nType)
    {
        switch (nType)
        {
        case DELL:
            return new Keyboard_DELL;
            break;
        case CHERRY:
            return new Keyboard_Cherry;
            break;
        case LOGITH:
            return new Keyboard_Logith;
        default:
            return NULL;
            break;
        }
    }
};

int _tmain(int argc, _TCHAR* argv[])
{
    Factory *facMouse = new Factory_Mouse;
    Factory *facKeyboard = new Factory_Keyboard;

    auto Imp = facMouse->ProductMouse(DELL);
    auto Imp2 = facKeyboard->ProductKeyboard(DELL);
    auto Imp3 = facMouse->ProductMouse(ASUS);

    Imp->Mouse_show();
    Imp2->Keyboard_show();
    Imp3->Mouse_show();

    getchar();
	return 0;
}