天天看點
傳回

淺談設計模式之一——簡單工廠、工廠、抽象工廠

這些天意識自身的不足，看着幾個同學跳槽後的高薪，實在是慚愧。畢業兩年，仍一事無成，差距也正逐漸展現出來。人們常說，設計模式是一個初級程式員到進階程式員的必經之路。為了補強自己，重新研究了GOF四人幫的<23種設計模式>，其實以前看過，隻是沒看懂，最近重新研究了一番，了解了一些，希望用通俗易懂的語言把它寫下來，或許對初學者有幫助，對自己也有提升。

設計模式分為建立型模式、行為型模式和結構型模式。建立型模式又分為5種，分别是抽象工廠（Abstract Factory）、工廠模式（Factory）、建造者模式（Builder）、原型模式（Prototype）和單例類模式（Singleton）。

注：GOF四人幫的<23種設計模式>中沒有簡單工廠。

這裡從建立型模式講起，首先講簡單工廠、工廠以及抽象工廠。

一、簡單工廠模式（Simple Factory）

首先先上uml圖，簡單工廠很簡單，但不夠靈活，其實大家經常用，隻是不知道這就是簡單工廠。uml圖相信大家都看得懂。

淺談設計模式之一——簡單工廠、工廠、抽象工廠

解析uml：一個父類産品，幾個子類繼承父類産品，一個具體工廠依賴具體産品。

這樣做的好處就是簡單，壞處也很明顯，不夠靈活，擴充性相對差。實作可以用多态來實作。多态有三個條件：一是父類的virtual，二是子類的覆寫（要求函數名、參數、傳回值都要一模一樣），三是父類的指針或引用指向子類的對象。

下面給出可執行的參考代碼：

SimpleFactory.h

#pragma once
#incldue<iostream>
using namespace std;

const int PRODOCTA=1;
const int PRODOCTB=2;
class AbstractProduct;

class Factory
{
public:
//construct
Factory(void);
//create a product
AbstractProduct * CreateProduct(int flag);

//destruct
~Factory(void);
};

class AbstractProduct
{
public:
virtual void Operation() = 0;

};

class ProductA:public AbstractProduct
{
public:
void Operation();

};

class ProductB:public AbstractProduct
{
public:
void Operation();

};

SimpleFactory.cpp

#include "Factory.h"
Factory::Factory(void)
{
}

Factory::~Factory(void)
{
}

AbstractProduct* Factory::CreateProduct(int flag)
{
switch(flag)
{
case PRODOCTA:
return new ProductA();
break;
case PRODOCTB:
return new ProductB();
break;
default:
return NULL;
break;
}



}

void ProductA::Operation()
{
cout<<"ProductA"<<endl;
}


void ProductB::Operation()
{
cout<<"ProductB"<<endl;
}

main.cpp

#include "Factory.h"
int main(int argc,char** argv)
{
    Factory f;
    f.CreateProduct(PRODOCTA)->Operation();
    f.CreateProduct(PRODOCTB)->Operation();

    getchar();
    return 0;
}

執行結果：

淺談設計模式之一——簡單工廠、工廠、抽象工廠

二、工廠模式（Factory）

同樣先上uml圖。

淺談設計模式之一——簡單工廠、工廠、抽象工廠

uml解析：一個抽象工廠，有若幹子工廠泛化，一個抽象産品，若幹子産品，工廠跟産品是依賴關系。跟簡單工廠相比，多了抽象工廠，使對象執行個體化延遲到子類。

可以這樣了解工廠模式，有很多電腦廠商，比如聯想，華碩，dell，蘋果等，如果你比較有錢，要生産一台蘋果的筆記本，那麼你可以通過AppleFactory生産一個AppleProduct，這樣做的好處就是不用再傳參數了。

下面給出可以直接運作的示例代碼：

Factory.h

#pragma once
#include "SimpleFactory.h"

class Factory
{
public:
    Factory(void);
    ~Factory(void);
public:
    virtual AbstractProduct * CreateProduct() = 0;

};

class ConcreteFactoryA: public Factory
{
public:
    AbstractProduct * CreateProduct();

};

class ConcreteFactoryB: public Factory
{
public:
    AbstractProduct *CreateProduct();

};

Factory.cpp

#include "Factory.h"

Factory::Factory(void)
{
}

Factory::~Factory(void)
{
}

AbstractProduct * ConcreteFactoryA::CreateProduct()
{
    return new ProductA;
}

AbstractProduct * ConcreteFactoryB::CreateProduct()
{
    return new ProductB;
}

main.cpp

#include "Factory.h"

int main(int argc,char** argv)
{
    ConcreteFactoryA *f1;
    f1 = new ConcreteFactoryA();
    ConcreteFactoryB *f2;
    f2 = new ConcreteFactoryB();
    f1->CreateProduct()->Operation();
    f2->CreateProduct()->Operation();

    getchar();
    return 0;
}

運作結果：

淺談設計模式之一——簡單工廠、工廠、抽象工廠

三、抽象工廠（Abstract Factory）

一樣先上uml

淺談設計模式之一——簡單工廠、工廠、抽象工廠

uml解析：跟工廠的差別就是産品也抽象了，不止一個産品，即工廠跟産品都抽象，而且産品的數量大于等于2。可以這麼了解，有華碩，dell，聯想，蘋果等廠商，你要一個蘋果的顯示器，聯想的主機闆，dell的滑鼠，這時你就可以用到抽象工廠，原因是抽象工廠把滑鼠，鍵盤，顯示器等否分開了，以便親你可以自己定制一個。

下面貼出可直接運作的示例代碼：

AbstractFactory.h

#pragma once
#include <iostream>
using namespace std;

class AbstractProductA
{
public:
    virtual void Operation() = 0;
};

class AbstractProductB
{
public:
    virtual void Operation() = 0;
};

class ConcreteProductA1:public AbstractProductA
{
public:
    void Operation();

};

class ConcreteProductA2:public AbstractProductA
{
public:
    void Operation();
};

class ConcreteProductB1:public AbstractProductB
{
public:
    void Operation();

};

class ConcreteProductB2:public AbstractProductB
{
public:
    void Operation();
};


class AbstractFactory
{
public:
    AbstractFactory(void);
    ~AbstractFactory(void);
public:
    virtual AbstractProductA* CreateProductA() = 0;
    virtual AbstractProductB* CreateProductB() = 0;
};

class AbstractFactoryA:public AbstractFactory
{
public:
    AbstractProductA * CreateProductA();
    AbstractProductB * CreateProductB();
};

class AbstractFactoryB:public AbstractFactory
{
public:
    AbstractProductA * CreateProductA();
    AbstractProductB * CreateProductB();
};

AbstractFactory.cpp

#include "AbstractFactory.h"

AbstractFactory::AbstractFactory(void)
{
}

AbstractFactory::~AbstractFactory(void)
{
}

AbstractProductA * AbstractFactoryA::CreateProductA()
{
    return new ConcreteProductA1();

}
AbstractProductB * AbstractFactoryA::CreateProductB()
{
    return new ConcreteProductB1();

}
AbstractProductA * AbstractFactoryB::CreateProductA()
{
    return new ConcreteProductA2();

}
AbstractProductB * AbstractFactoryB::CreateProductB()
{
    return new ConcreteProductB2();

}


void ConcreteProductA1::Operation()
{
    cout<<"concreteProductA1"<<endl;
}
void ConcreteProductA2::Operation()
{
    cout<<"concreteProductA2"<<endl;
}
void ConcreteProductB1::Operation()
{
    cout<<"concreteProductB1"<<endl;
}
void ConcreteProductB2::Operation()
{
    cout<<"concreteProductB2"<<endl;
}

main.cpp

#include "AbstractFactory.h"

int main(int argc,char** argv)
{
    AbstractFactory* f1 = new AbstractFactoryA();
    AbstractFactory* f2 = new AbstractFactoryB();
    f1->CreateProductA()->Operation();
    f1->CreateProductB()->Operation();
    f2->CreateProductA()->Operation();
    f2->CreateProductB()->Operation();

    getchar();
    return 0;
}

運作結果如圖：

淺談設計模式之一——簡單工廠、工廠、抽象工廠

好了，到此為止，三種工廠模式就全部介紹完，希望對你有幫助，也希望對自己有幫助，寫部落格還真是累，給個贊吧O(∩_∩)O~thx

設計模式 工廠模式 GoF 進階程式員 模式
上一篇: 1-04 對象與類
下一篇: 1-03 Java的基本程式設計結構

繼續閱讀