设计模式——简单工厂+策略模式

主要参考：《大话设计模式》

1.简单工厂模式：

输入：对象特征（字符串）

输出：对象

方法：Factory，选取对象

选取方式：利用switch选取对象。

优点：客户不需要知道具体调用哪个对象，只需要知道使用该对象特征。

弱点：封装性不够高，客户端须知道工厂与需操作对象（抽象类）两个类。

2.策略模式：

输入：需操作的对象

输出：最终结果

方法：Result，统一调用各个策略算法。

选取方法：利用多态，传入不同对象选取。

优点：进一步将子对象（策略）进行封装，客户不需要了解对象实现细节。

弱点：客户需指定调用的具体对象。

3.简单工厂+策略模式：

结合两者优点，进行深度封装，使得客户仅仅需要提供对象特征（字符串）和了解Contex类。

输入：对象特征

输出：最终结果

优点：客户不需要知道具体调用哪个对象，也不需要知道这个对象所拥有的方法，只需要知道Contex的对象。

缺点：Context类中仍然用到switch选择判断正确的对象。

例子杂糅版（C++）：

Main.cpp

// SimpleFactory.cpp : 定义控制台应用程序的入口点。
//

#include "stdafx.h"

#include <iostream>
using namespace std;

int _tmain(int argc, _TCHAR* argv[])
{
	int lval=10,rval=5;
/*
*	Only know OperatorFactory is enough.
*/
	cout<<"Simple Factory & Stratage"<<endl;
	OperatorFactory StrageAndSFactory("+");
	cout<<lval<<"+"<<rval<<"="<<StrageAndSFactory.getRes(lval,rval)<<endl;

/*
*	Need know OperatorFactory and Operator.
*/
	cout<<"--------------------------"<<endl<<"Simple Factory"<<endl;
	OperatorFactory mFactory;
	Operator* oper;
	oper = mFactory.ProduceOperator("+");
	cout<<lval<<"+"<<rval<<"="<<oper->doOperator(lval,rval)<<endl;
	oper = mFactory.ProduceOperator("-");
	cout<<lval<<"-"<<rval<<"="<<oper->doOperator(lval,rval)<<endl;
	oper = mFactory.ProduceOperator("*");
	cout<<lval<<"*"<<rval<<"="<<oper->doOperator(lval,rval)<<endl;
	return 0;
}

OperatorFactory.h

#pragma once
#include "Operator.h"
#include <string>
#include <map>
using std::string;
using std::map;
class OperatorFactory
{
public:
	OperatorFactory();
	OperatorFactory(string);
	virtual ~OperatorFactory(void);
	map<string,int> m_map;
	Operator* ProduceOperator(string);
	Operator* oper;
	int getRes(int,int);
};

OperatorFactory.h

#include "StdAfx.h"
#include "OperatorFactory.h"
#include <map>
using namespace std;

OperatorFactory::OperatorFactory()
{
	m_map["+"]=0;
	m_map["-"]=1;
	m_map["*"]=2;
}

OperatorFactory::OperatorFactory(string type)
{
	m_map["+"]=0;
	m_map["-"]=1;
	m_map["*"]=2;
	oper = ProduceOperator(type);
}


OperatorFactory::~OperatorFactory(void)
{
}

Operator* OperatorFactory::ProduceOperator(string type){
	switch(m_map[type]){
	case 0:
		return new OperatorAdd();
		break;
	case 1:
		return new OperatorSub();
		break;
	case 2:
		return new OperatorMultiple();
	default:
		break;
	}
	return NULL;
}

int OperatorFactory::getRes(int lval,int rval){
	return oper->doOperator(lval,rval);
}

Operator.h

#pragma once

class Operator
{
public:
	Operator(void);
	virtual int doOperator(int lval,int rval)=0;
	virtual ~Operator(void);
};

OperatorAdd.h

#pragma once
#include "Operator.h"
class OperatorAdd :
	public Operator
{
public:
	OperatorAdd(void);
	virtual int doOperator(int,int);
	virtual ~OperatorAdd(void);
};

int OperatorAdd::doOperator(int lval,int rval){
	return lval+rval;
}