文章目錄
-
- 1. 什麼是工廠模式？
- 2. 工廠模式的适用場景？
-
- 2.1 優缺點
- 3. 怎樣使用工廠模式？
-
- 3.1 方法
- 3.2 UML類圖
- 4. 執行個體
-
- 4.1 結果（結論先行）
- 4.2 具體實作：工廠繼承體系函數接口
- 4.3 具體實作：電腦繼承體系函數接口
1. 什麼是工廠模式？
工廠方法模式（Factory Method），定義一個用于建立對象的接口，讓子類決定執行個體化哪一個類。工廠方法使一個類的執行個體化延遲到其子類。
2. 工廠模式的适用場景？
2.1 優缺點
優勢：
克服了簡單工廠方式違背的"開放-封閉原則"（簡單工廠不但對擴充開放了，對修改也開放了），工廠方法，最起碼對修改封裝了起來，降低了客戶程式對産品對象的耦合。
工廠方法模式就是簡單工廠模式的進一步抽象和推廣。
弊端：
1、由于每增加一個産品，就需要加一個産品工廠的類，增加了額外的開發量。
2、需要用戶端決定執行個體化哪一個具體工廠，選擇判斷問題依然存在，隻是将簡單工廠的内部邏輯判斷轉移到了用戶端代碼進行，想要加功能，本來修改工廠類，現在修改用戶端，
如何規避工廠方法的弊端？
利用"反射"可以避免分支判斷的問題，具體優化見：抽象工廠模式之反射的應用（待續）。
3. 怎樣使用工廠模式？
3.1 方法
使用"依賴倒轉原則"，解耦工廠類與分支：
step1：把工廠類抽象出一個接口，這個接口隻有一個方法，就是建立抽象産品的工廠方法。
step2：所有要生産具體類的工廠，都繼承工廠基類，并去實作這個接口；
這樣，一個簡單工廠模式的工廠類，就變成了一個工廠抽象接口和多個具體生成對象的工程。
eg：當我們需要添加"幂運算"功能時，就無需更改原有的工廠類了，隻需增加此功能的運算類和相應的工廠類即可。
3.2 UML類圖
4. 執行個體
4.1 結果（結論先行）
#include <iostream>
#include "AddFactory.h"
#include "SubFactory.h"
#include "MulFactory.h"
#include "DivFactory.h"
#include "Operation.h"
using namespace std;
void test0()
{
//=============加=================
IFactory* pFactory = new AddFactory();
Operation* pOper = pFactory->createOperation();
pOper->setNumberA(20);
pOper->setNumberB(10);
cout << "A = " << pOper->getNumberA() << ",\tB = " << pOper->getNumberB() << endl;
cout << "add result = " << pOper->getResult() << endl;
//=============減=================
pOper = (new SubFactory())->createOperation();
pOper->setNumberA(20);
pOper->setNumberB(10);
cout << "div result = " << pOper->getResult() << endl;
//=============乘=================
pOper = (new MulFactory())->createOperation();
pOper->setNumberA(20);
pOper->setNumberB(10);
cout << "mul result = " << pOper->getResult() << endl;
//=============除=================
pOper = (new DivFactory())->createOperation();
pOper->setNumberA(20);
pOper->setNumberB(10);
cout << "div result = " << pOper->getResult() << endl;
delete pFactory;
delete pOper;
pFactory = nullptr;
pOper = nullptr;
}
int main()
{
test0();
system("pause");
return 0;
}
4.2 具體實作：工廠繼承體系函數接口
4.2.1 IFactory.h
#pragma once
#include "Operation.h"
class IFactory
{
public:
IFactory() {}
virtual ~IFactory() {}
virtual Operation* createOperation() = 0;
};
4.2.2 AddFactory.h
#pragma once
#include "IFactory.h"
#include "OperationAdd.h"
class AddFactory :
public IFactory
{
public:
AddFactory() :IFactory() {}
virtual ~AddFactory() {}
virtual Operation* createOperation() override
{
return new OperationAdd();
}
};
4.2.3 SubFactory.h
#pragma once
#include "IFactory.h"
#include "OperationSub.h"
class SubFactory :
public IFactory
{
public:
SubFactory() {}
virtual ~SubFactory() {}
virtual Operation* createOperation() override
{
return new OperationSub();
}
};
4.2.4 MulFactory.h
#pragma once
#include "IFactory.h"
#include "OperationMul.h"
class MulFactory :
public IFactory
{
public:
MulFactory() :IFactory() {}
virtual ~MulFactory() {}
virtual Operation* createOperation() override
{
return new OperationMul();
}
};
4.2.5 DivFactory.h
#pragma once
#include "IFactory.h"
#include "OperationDiv.h"
class DivFactory :
public IFactory
{
public:
DivFactory() :IFactory() {}
virtual ~DivFactory() {}
virtual Operation* createOperation() override
{
return new OperationDiv();
}
};
4.3 具體實作：電腦繼承體系函數接口
4.2.1 Operation.h
#pragma once
class Operation
{
public:
Operation() {}
virtual ~Operation() {}
virtual double getResult() = 0;
void setNumberA(double a) { m_nNumberA = a; }
void setNumberB(double b) { m_nNumberB = b; }
double getNumberA() { return m_nNumberA; }
double getNumberB() { return m_nNumberB; }
protected:
double m_nNumberA;
double m_nNumberB;
};
4.3.2 OperationAdd.h
#pragma once
#include "Operation.h"
class OperationAdd :
public Operation
{
public:
OperationAdd() :Operation() {}
virtual ~OperationAdd() {}
virtual double getResult() override
{
return m_nNumberA + m_nNumberB;
}
};
4.3.3 OperationSub.h
#pragma once
#include "Operation.h"
class OperationSub :
public Operation
{
public:
OperationSub() :Operation() {}
virtual ~OperationSub() {}
virtual double getResult() override
{
return m_nNumberA - m_nNumberB;
}
};
4.3.4 OperationMul.h
#pragma once
#include "Operation.h"
class OperationMul :
public Operation
{
public:
OperationMul() :Operation() {}
virtual ~OperationMul() {}
virtual double getResult() override
{
return m_nNumberA * m_nNumberB;
}
};
4.3.5 OperationDiv.h
#pragma once
#include "Operation.h"
#include <iostream>
using namespace std;
class OperationDiv :
public Operation
{
public:
OperationDiv() :Operation() {}
~OperationDiv() {}
virtual double getResult() override
{
if (m_nNumberB == 0)
{
cout << "分母為0，傳回0" << endl;
return 0;
}
return m_nNumberA / m_nNumberB;
}
};
此為《大話設計模式》學習心得系列 P69~~