文章目录
-
- 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~~