设计模式的分类
总体来说设计模式分为三大类:
创建型模式,共五种:工厂方法模式、抽象工厂模式、单例模式、建造者模式、原型模式。结构型模式,共七种:适配器模式、装饰器模式、代理模式、外观模式、桥接模式、组合模式、享元模式。
行为型模式,共十一种:策略模式、模板方法模式、观察者模式、迭代子模式、责任链模式、命令模式、备忘录模式、状态模式、访问者模式、中介者模式、解释器模式。
六大原则
http://www.2cto.com/kf/201606/520418.html
(一)简单工厂模式
http://blog.csdn.net/dwb1015/article/details/18094583
在不确定会有多少个处理操作时应该考虑使用简单工厂模式,如针对同样的接收到的数据,处理的逻辑可能会不同,可能以后还会增加新的操作。
案例:
例如如果实现计算器的功能时,对于同样的输入数据,可能执行加、减、乘、除,甚至其他的功能。因此可以抽象出一个操作的抽象类或是接口,提供一个统一的处理方法(此处为process),然后每种操作创建出一个子类出来。而判断具体使用哪个具体的实现类是在工厂类中进行判断的(将存放操作的变量传递给工厂的生产方法)。工厂类始终返回的是这个抽象类,这样如果对原有功能进行更改或是新添加新的功能,也不会对原来的其他类做修改,只编译修改的那个类或是新的类就可以了。
这样就做到了把耦合降到最低,同时也便于维护。
注意:如果客户提出要再添加一个功能来处理这些数据,实现起来就灰常方便了
项目结合:
计算某区域的形状因子,,平均亮度,等效圆半径,最大最小Frete直径,等,输入是这个区域的坐标的集合,输出是对应的数据。
产品有自己的基类和派生类,分别定义不同的操作。工厂类只是负责创建一个统一的处理方法,返回一个具体方法的基类引用。根据不同的参数返回一个指向子类的指针。
工厂对象的工厂函数根据用户输入,自动new出一个子类对象并返回其父类的指针,这样利用父类的指针执行父类的虚函数,就可以动态绑定子类的重写函数,从而实现多态
class _operation1{
public:
int a, b;
char c;
virtual double Getresult(){ return 0; };
};
class add :public _operation1{
virtual double Getresult(){ return a + b; };
};
class mul :public _operation1{
virtual double Getresult(){ return a * b; };
};
class sub :public _operation1{
virtual double Getresult(){ return a - b; };
};
class jian :public _operation1{
virtual double Getresult()
{
if (-0.000001 < b&&b < 0.000001)
{
//cout << "shabi" << endl;
throw b;
}
return a / b;
}
};
class Factory{
public:
static _operation1 * createoperation(char ch){
switch (ch)
{
default:
throw exception("非法操作符");
case'+':
return new add();
case '-':
return new sub();
case'*':
return new mul();
case '/':
return new jian();
}
}
};
int _tmain(int argc, _TCHAR* argv[])
{
int a = 0;
int b = 0;
char ch = '\0';
cin >> a >> ch>> b;
try{
shared_ptr <_operation1> p(Factory::createoperation(ch));
try{
p->a = a;
p->b = b;
cout << p->Getresult()<< endl;
}
catch (int)
{
cout << "除数不能为0000" << endl;
exit(1);
}
}
catch (exception& e)
{
cout << e.what() << endl;
}
return 0;
}
return 0;
}
try catch:
http://jingyan.baidu.com/article/358570f64128c6ce4624fc55.html
(二)工厂方法模式
简单工厂模式在工厂类里面不仅定义了方法,还指明了根据输入的不同调用哪个产品的生产子类。这样的缺点就是:每次增加一种产品,除了增加产品生产线(产品子类),还要在工厂类里面去增加,这样违背了封闭原则。
开放封闭原则:软件实体(类、模块、函数)可以扩展,但是不可修改。于是,工厂方法模式出现了。所谓工厂方法模式,是指定义一个用于创建对象的接口,让子类决定实例化哪一个类。Factory Method使一个类的实例化延迟到其子类。
只在工厂类内声明方法,而具体实例化哪一个产品生产线由工厂的子类决定,这样,在客户端用的时候,需要实例化哪个产品就直接在客户端代码里面增加工厂对应的子类,实现增删减改。不用再到工厂类里面去增加case语句了。
class Factory{
public:
virtual _operation1* createoperation(char ch) {
throw exception("非法操作符");
}
};
class Factory_add :public Factory{
public:
virtual _operation1* createoperation(char ch)
{
return new add();
}
};
class Factory_sub :public Factory{
public:
virtual _operation1* createoperation(char ch)
{
return new sub();
}
};
class Factory_mul :public Factory{
public:
virtual _operation1* createoperation(char ch)
{
return new mul();
}
};
class Factory_jian :public Factory{
public:
virtual _operation1* createoperation(char ch)
{
return new jian();
}
};
/*工厂方法模式*/
int _tmain(int argc, _TCHAR* argv[])
{
int a = 0;
int b = 0;
char ch = '\0';
cin >> a >> ch>> b;
Factory * fac;
try{
switch (ch)
{
default:
fac = new Factory;
break;
case'+':
fac = new Factory_add;
break;
case '-':
fac = new Factory_sub;
break;
case'*':
fac = new Factory_mul;
break;
case '/':
fac = new Factory_jian;
break;
}
shared_ptr<_operation1> p(fac->createoperation(ch));
try{
p->a = a;
p->b = b;
cout << p->Getresult()<< endl;
}
catch (int)
{
cout << "除数不能为0000" << endl;
exit(1);
}
}
catch (exception& e)
{
cout << e.what() << endl;
}
return 0;
}
用到哪个运算,就在客户端(main)代码里面new一个工厂子类就可以了。
(三)抽象工厂模式
这个好抽象的感觉。
http://blog.csdn.net/wuzhekai1985/article/details/6660462
抽象工厂模式是工厂方法模式的升级版本,他用来创建一组相关或者相互依赖的对象。他与工厂方法模式的区别就在于,工厂方法模式针对的是一个产品等级结构;而抽象工厂模式则是针对的多个产品等级结构。在编程中,通常一个产品结构,表现为一个接口或者抽象类,也就是说,工厂方法模式提供的所有产品都是衍生自同一个接口或抽象类,而抽象工厂模式所提供的产品则是衍生自不同的接口或抽象类。
什么j8玩意。
我理解的就是工厂模式下工厂类只定义了一种方法,而抽象模式下工厂类可以定义多个方法,生产多个产品。
http://ichennan.com/2016/08/09/DesignPattern.html