设计模式(简单工厂模型)

2016-12-21

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

设计模式:

设计模式(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目标