设计模式（简单工厂模型）

2016-12-21
#design

版权声明:本文为作者原创文章，可以随意转载，但必须在明确位置表明出处！！！

设计模式：

设计模式（Design pattern）是一套被反复使用、多数人知晓的、经过分类编目的、代码设计经验的总结。使用设计模式是为了可重用代码、让代码更容易被他人理解、保证代码可靠性。

设计模式的六大原则：

  1. 开闭原则：

    对扩展开放，对修改关闭。在程序需要进行扩展的时候，不能去修改原有的代码，实现一种热插拔的效果。这样有利于程序的可维护性和易升级性。

  2. 里氏代换原则：

    里氏代换原则是面向对象设计的基本原则之一，里氏代换原则中说，任何基类可以出现的地方，子类一定可以出现，里氏代换原则是继承复用的基础，只有当派生类可以替换基类，且原有功能不被影响时基类才能真正被复用，而派生类也能够在基类的基础上新增新的行为。里氏代换原则是对开闭原则的补充，实现开闭原则的关键步骤就是抽象化，而基类和子类的继承关系就是抽象化的具体实现。

  3. 依赖倒转原则：

    这个原则是开闭原则的基础，它是针对接口编程，依赖抽象而不依赖具体

  4. 接口隔离原则：

    使用多个隔离的接口，比使用单个接口要好。它的另外一个意识是降低类之间的耦合度。

  5. 迪米特法则：

    迪米特发展又称最少知道原则，一个实体应当尽量少的与其它实体之间发生相互作用，使得系统功能模块相对独立。

  6. 合成复用原则：

    尽量使用合成/聚合的方式，而不是使用继承方式。

简单工厂模式

简单工厂模式是最常用的设计模式之一，它是一种创建型模式，它提供了一种创建对象的最佳方式。

优点

  1. 调用者想创建一个对象，只需要知道其名称就可以了。
  2. 扩展性高，如果想新增一个产品，只需要扩展一个新增产品类就可以了。
  3. 屏蔽产品的具体实现，调用者只关心产品接口。

缺点

每新增一个产品就需要新增一个类和对象实现工厂，若产品不停的增加，会在一定程度上增加系统的复杂度，同时也增加了系统具体类的依赖

实现

此系列的设计用例全部来自《大话设计模式》此书，此系列尽量使用C++模板来实现

  • 步骤一

    创建一个工厂
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
#文件operatorFactory.h
#ifndef __OPERATORFACOTRY__
#define __OPERATORFACOTRY__
#include "operation.h"
template<class T>
class COperatorFactory
{
public:
	COperatorFactory();
	~COperatorFactory();
public:
	COperation<T>* createOperator(char operate);
};
#endif
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
#文件operatorFactory.cpp
#include "operatorFactory.h"
#include "operatorAdd.h"
#include "operatorSub.h"
#include "operatorMul.h"
#include "operatorDiv.h"
template<class T>
COperatorFactory<T>::COperatorFactory()
{
	
}
template<class T>
COperatorFactory<T>::~COperatorFactory()
{
	
}
template<class T>
COperation<T>* COperatorFactory<T>::createOperator(char operate)
{
	COperation<T> *oper;
	switch(operate)
	{
		case '+':
			oper = new COperatorAdd<T>;
			break;
		case '-':
			oper = new COperatorSub<T>();
			break;
		case '*':
			oper = new COperatorMul<T>();
			break;
		case '/':
			oper = new COperatorDiv<T>();
			break;
		default:
			oper = 0;
	}
	
	return oper;
}

  • 步骤二：

    创建一个操作基类
1
2
3
4
5
6
7
8
9
10
11
12
13
#文件operation.h
#ifndef __OPERATION__
#define __OPERATION__
template<class T>
class COperation
{
public:
	COperation(){};
  virtual ~COperation(){};
public:
	virtual T getResult(const T* a, const T* b) = 0;
};

  • 步骤三：

    创建一个操作实体类
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
#文件operatorAdd.h
#ifndef __OPERATORADD__
#define __OPERATORADD__
#include "operation.h"
template<class T>
class COperatorAdd : public COperation<T>
{
public:
	COperatorAdd();
  ~COperatorAdd();
public:
	virtual T getResult(const T*, const T*);	
};
#endif
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
#文件operatorAdd.cpp
#include "operatorAdd.h"
template<class T>
COperatorAdd<T>::COperatorAdd()
{
	
}
template<class T>
COperatorAdd<T>::~COperatorAdd()
{
	
}
template<class T>
T COperatorAdd<T>::getResult(const T* a, const T* b)
{
	return *a + *b;	
}

其它操作实体类是同样的实现方式这里就不一一列出了，

测试

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
#include <iostream>
#include "operatorFactory.cpp"
#include "operation.cpp"
#include "operatorAdd.cpp"
#include "operatorSub.cpp"
#include "operatorMul.cpp"
#include "operatorDiv.cpp"
int main(void)
{
	COperation<int> *oper;
	COperatorFactory<int>factory;
	oper = factory.createOperator('/');
	int a = 10;
	int b = 20;
	int nRet = oper->getResult(&a, &b);
	std::cout<<"nRet = "<< nRet << std::endl;
	return 0;
}

UML类图

项目文件：https://github.com/Gavinxyj/designPattern

推荐我的微信公众号：爱做饭的老谢

上一篇：基于模板类的排序算法（基数排序，堆排序）
下一篇：2016总结，2017目标