1. 工厂方法模式
定义一个用于创建对象的接口, 让子类决定实例化哪一个类,工厂方法使一个类的实例化延迟到其子类。
和简单工厂模式相比:
A: 简单工厂模式最大的优点在于工厂类中包含有必要的逻辑判断, 根据客户端的选择条件动态实例化相关的类,对客户端来说去除了与具体产品的依赖。
但缺点是 添加新产品时 需要修改工厂类 case, 违背了 "开放-封闭" 原则。
B: 工厂方法模式实现时,需要由客户端来决定实例化哪一个工厂来实现运算类,选择判断的问题还是存在,只是由工厂类内部转移到客户端。
实例:
operation.h -- operation.cpp
#ifndef OPERATION_H
#define OPERATION_H
class Operation
{
public:
Operation();
double virtual getResult();
double strA;
double strB;
double result;
};
#endif // OPERATION_H
#include "operation.h"
Operation::Operation()
{
strA = 0;
strB = 0;
result = 0;
}
double Operation::getResult()
{
return result;
}
operationfunc.h operationfunc.cpp
#ifndef OPERATIONFUNC_H
#define OPERATIONFUNC_H
#include "operation.h"
class OperationAdd : public Operation
{
public:
double getResult();
};
class OperationSub : public Operation
{
public:
double getResult();
};
class OperationMul : public Operation
{
public:
double getResult();
};
class OperationDiv : public Operation
{
public:
double getResult();
};
#include "operationfunc.h"
double OperationAdd::getResult()
{
result = strA + strB;
return result;
}
double OperationSub::getResult()
{
result = strA - strB;
return result;
}
double OperationMul::getResult()
{
result = strA * strB;
return result;
}
double OperationDiv::getResult()
{
result = strA / strB;
return result;
}
factory.h factory.cpp 抽象工厂
#ifndef FACTORY_H
#define FACTORY_H
#include "operation.h"
#include "operationfunc.h"
#include <string>
using namespace std;
class Factory
{
public:
Factory();
virtual Operation* createOperation();
};
#endif // FACTORY_H
#include "factory.h"
Factory::Factory()
{
}
Operation* Factory::createOperation()
{}
addfactory.h addfactory.cpp
#ifndef ADDFACTORY_H
#define ADDFACTORY_H
#include "factory.h"
class AddFactory : public Factory
{
public:
AddFactory();
Operation* createOperation();
};
#endif // ADDFACTORY_H
#include "addfactory.h"
AddFactory::AddFactory()
{
}
Operation* AddFactory::createOperation()
{
return new OperationAdd();
}
subfactory.h subfactory.cpp
#ifndef SUBFACTORY_H
#define SUBFACTORY_H
#include "factory.h"
class SubFactory : public Factory
{
public:
SubFactory();
Operation* createOperation();
};
#endif // SUBFACTORY_H
#include "subfactory.h"
SubFactory::SubFactory()
{
}
Operation* SubFactory::createOperation()
{
return new OperationSub();
}
main.cpp
#include <iostream>
#include "operationfunc.h"
#include "addfactory.h"
#include "subfactory.h"
using namespace std;
int main()
{
cout << "Factory method " << endl;
Factory *factory = new SubFactory();
Operation *oper = factory->createOperation();
oper->strA = 1.1;
oper->strB = 2.3;
cout << "result: " << oper->getResult() << endl;
return 0;
}