设计模式之--简单工厂模式
2016-12-06 15:44
337 查看
今天看《大话设计模式》,然后网上搜相关代码验证一下,看到了这篇博客:http://www.cnblogs.com/sdlypyzq/archive/2012/08/14/2637759.html,开头几句话甚得我心。
是啊,“衣带渐宽终不悔,为伊消得人憔悴”,那不就是我吗。
参考文章还有:http://blog.csdn.net/weiwenlongll/article/details/6918164
好了,下面是正文。
简单工厂模式:
简单工厂模式(Simple Factory Pattern)属于类的创新型模式,又叫静态工厂方法模式(Static Factory Method Pattern),是通过专门定义一个类来负责创建其他类的实例,被创建的实例通常都具有共同的父类。
简单工厂模式的UML图:
简单工厂模式包含的角色及相应的职责如下:
工厂角色(Creator):这是简单工厂模式的核心,由它负责创建所有的类的内部逻辑。当然工厂类必须能够被外部调用,创建所需的产品对象。
抽象产品角色(Product):简单工厂模式所创建的所有对象的父类。注意这里的父类可以是接口也可以是抽像类,它负责描述所有实例锁共有的公共接口。
具体产品角色(Concreate Produce):简单工厂所创建的具体实例对象,这些具体的产品往往都拥有共同的父类。
简单工厂模式理解:
简单工厂模式解决的问题是如何去实例化一个合适的对象。
简单工厂模式的核心思想就是:有一个类来负责创建实例的过程。具体来说,把产品看成一系列类的集合,这些类是由某个抽象类或者接口派生出来的一个对象树。而工厂类用来产生一个合适的对象来满足客户的要求。
如果简单工厂模式所涉及到的具体产品之间没有共同的逻辑,那么我们就可以使用接口来扮演抽象产品的角色;如果具体产品之间有功能的逻辑或,我们就必须把这些共同的东西提取出来,放在一个抽象类中,然后让具体产品继承抽象类。为实现更好复用的目的,共同的东西总是应该抽象出来的。
下面举例一段代码,是《大话设计模式》一书中第一个例子:
.h文件:
#ifndef _FACTORY_H
#define _FACTORY_H
#include <assert.h>
#include <iostream>
#include <stdlib.h>
class operators {
public:
void set_operator_nums(int num1, int num2) {
num1_ = num1;
num2_ = num2;
}
virtual int get_result() = 0;
protected:
int num1_;
int num2_;
};
class operator_add : public operators {
public:
int get_result() {
return num1_ + num2_;
}
};
class operator_sub : public operators {
public:
int get_result() {
return num1_ - num2_;
}
};
class operation_factory {
public:
static operators* get_operator(char ch){
assert(ch == '+' || ch == '-');
operators* oper = NULL;
try {
switch(ch){
case '+':
oper = new operator_add;
break;
case '-':
oper = new operator_sub;
break;
}
}
catch(std::bad_alloc& e){
std::cout<<e.what()<<std::endl;
exit(1);
}
return oper;
}
};
#endif
测试文件:
#include "factory.h"
#include <assert.h>
#include <iostream>
using namespace std;
int main()
{
//operators op; //error, abstruct class can not declare a object.
char operate = '+';
operators* oper = operation_factory::get_operator(operate);
oper->set_operator_nums(3, 4);
int result = oper->get_result();
assert(result == 7);
operate = '-';
oper = operation_factory::get_operator(operate);
oper->set_operator_nums(4, 3);
result = oper->get_result();
assert(result == 1);
delete oper;
return 0;
}
我们需要做一个具有加减功能的计算器。那我们就把加减操作提取出来封装成operator_add和operator_sub两个类,把它们共同逻辑操作数提取出来放在抽象类operators中,
使用了一个工厂类operation_factory来实例化我们需要的操作对象,operators获得子类的指针,这是多态的表现,然后调用指向子类的方法,获得计算结果。
是啊,“衣带渐宽终不悔,为伊消得人憔悴”,那不就是我吗。
参考文章还有:http://blog.csdn.net/weiwenlongll/article/details/6918164
好了,下面是正文。
简单工厂模式:
简单工厂模式(Simple Factory Pattern)属于类的创新型模式,又叫静态工厂方法模式(Static Factory Method Pattern),是通过专门定义一个类来负责创建其他类的实例,被创建的实例通常都具有共同的父类。
简单工厂模式的UML图:
简单工厂模式包含的角色及相应的职责如下:
工厂角色(Creator):这是简单工厂模式的核心,由它负责创建所有的类的内部逻辑。当然工厂类必须能够被外部调用,创建所需的产品对象。
抽象产品角色(Product):简单工厂模式所创建的所有对象的父类。注意这里的父类可以是接口也可以是抽像类,它负责描述所有实例锁共有的公共接口。
具体产品角色(Concreate Produce):简单工厂所创建的具体实例对象,这些具体的产品往往都拥有共同的父类。
简单工厂模式理解:
简单工厂模式解决的问题是如何去实例化一个合适的对象。
简单工厂模式的核心思想就是:有一个类来负责创建实例的过程。具体来说,把产品看成一系列类的集合,这些类是由某个抽象类或者接口派生出来的一个对象树。而工厂类用来产生一个合适的对象来满足客户的要求。
如果简单工厂模式所涉及到的具体产品之间没有共同的逻辑,那么我们就可以使用接口来扮演抽象产品的角色;如果具体产品之间有功能的逻辑或,我们就必须把这些共同的东西提取出来,放在一个抽象类中,然后让具体产品继承抽象类。为实现更好复用的目的,共同的东西总是应该抽象出来的。
下面举例一段代码,是《大话设计模式》一书中第一个例子:
.h文件:
#ifndef _FACTORY_H
#define _FACTORY_H
#include <assert.h>
#include <iostream>
#include <stdlib.h>
class operators {
public:
void set_operator_nums(int num1, int num2) {
num1_ = num1;
num2_ = num2;
}
virtual int get_result() = 0;
protected:
int num1_;
int num2_;
};
class operator_add : public operators {
public:
int get_result() {
return num1_ + num2_;
}
};
class operator_sub : public operators {
public:
int get_result() {
return num1_ - num2_;
}
};
class operation_factory {
public:
static operators* get_operator(char ch){
assert(ch == '+' || ch == '-');
operators* oper = NULL;
try {
switch(ch){
case '+':
oper = new operator_add;
break;
case '-':
oper = new operator_sub;
break;
}
}
catch(std::bad_alloc& e){
std::cout<<e.what()<<std::endl;
exit(1);
}
return oper;
}
};
#endif
测试文件:
#include "factory.h"
#include <assert.h>
#include <iostream>
using namespace std;
int main()
{
//operators op; //error, abstruct class can not declare a object.
char operate = '+';
operators* oper = operation_factory::get_operator(operate);
oper->set_operator_nums(3, 4);
int result = oper->get_result();
assert(result == 7);
operate = '-';
oper = operation_factory::get_operator(operate);
oper->set_operator_nums(4, 3);
result = oper->get_result();
assert(result == 1);
delete oper;
return 0;
}
我们需要做一个具有加减功能的计算器。那我们就把加减操作提取出来封装成operator_add和operator_sub两个类,把它们共同逻辑操作数提取出来放在抽象类operators中,
使用了一个工厂类operation_factory来实例化我们需要的操作对象,operators获得子类的指针,这是多态的表现,然后调用指向子类的方法,获得计算结果。
相关文章推荐
- C#设计模式学习笔记---简单工厂模式
- C#设计模式之简单工厂篇
- 用 Delphi 学设计模式 之 简单工厂篇- -
- 设计模式 之 简单工厂
- JAVA设计模式——简单工厂(Simple Factory)模式
- .NET设计模式(1): 简单工厂模式
- C#设计模式之简单工厂篇
- 设计模式之-简单工厂、工厂方法、抽象工厂
- C#设计模式之简单工厂篇
- 第一个设计模式:简单工厂
- 最简单的工厂设计模式 Factory
- [导入]C#设计模式之简单工厂篇
- C#设计模式之简单工厂
- 简单工厂设计模式-设计模式(1)
- 设计模式之Factory1(简单工厂,工厂方法,抽象工厂的比较)
- C#设计模式之简单工厂篇
- C#设计模式之简单工厂篇
- Dot Net 设计模式—简单工厂
- 简单工厂设计模式
- 设计模式-工厂模式-简单工厂