大话设计模式
1 策略模式UML图
2 策略模式的概念
策略模式(Strategy):它定义了算法家族,分别封装起来,让它们之间可以相互替换,此模式让算法的变化,不会影响到算法的客户。【DP】
3 策略模式和简单工厂模式的比较
简单工厂模式需要让客户端认识两个类,而策略模式和简单工厂结合的用法,客户端就只需要认识一个类就可以了,耦合度更低。
4 策略模式解析
- 策略模式是一种定义一系列算法的方法,从概念上来看,所有这些算法完成的都是相同的工作,只是实现不同,他可以以相同的方式调用所有的算法,减少了各种算法类与使用算法类之间的耦合。【DPE】
- 策略模式的Strategy类层次为Context定义了一些列的可供重用的算法或行为。集成有助于析取出这些算法中的公共功能。【DP】
- 策略模式简化了单元测试,因为每个算法都有自己的类,可以通过自己的接口单独测试。【DPE】
- 当不同的行为堆砌在一个类中时,就很难避免使用条件语句来选择合适的行为。将这些行为封装在一个个独立的Strategy类中,可以在使用这些行为的类中消除条件语句。【DP】。如收费系统中,客户端出去了条件语句,避免了判断。
- 策略模式就是用来封装算法的。
- 只要在分析过程中听到需要在不同时间应用不同的业务规则,就可以考虑使用策略模式处理这种变化的可能性。
- 在基本的策略模式中,选择所用具体实现的职责由客户端对象承担,并转给策略模式的Context对象。【DPE】
5 更好的办法
反射机制。在抽象工厂模式中有对反射的讲解
6 C++代码实现
题目:做一个商场收银软件,营业员根据客户所购买商品的单价和数量,向客户收费。
策略模式实现UML图
(1)策略类:Strategy
#include<iostream>
#include<cmath>
#include<vector>
using namespace std;
//定义所有支持的算法的公共接口
//现金收费抽象类
class CashSuper
{
public:
virtual double acceptCash(double money) = 0;
};
//封装了具体的算法或者行为,继承与Strategy
//正常收费子类
class CashNormal :public CashSuper
{
public:
double acceptCash(double money) override
{
return money;
}
};
//封装了具体的算法或者行为,继承与Strategy
//打折收费子类
class CashRebate :public CashSuper
{
private:
double moneyRebate = 1.0;
public:
CashRebate(double rebate)
{
moneyRebate = rebate;
}
double acceptCash(double money) override
{
return money*moneyRebate;
}
};
//封装了具体的算法或者行为,继承与Strategy
//返利收费子类
class CashReturn :public CashSuper
{
private:
double moneyCondition = 0;
double moneyReturn = 0;
public:
//返利收费,初始化时必须要输入返利条件和返利值,比如满300减100,则moneyCondition2=300,moneyReturn2=100
CashReturn(double moneyCondition2, double moneyReturn2)
{
moneyCondition = moneyCondition2;
moneyReturn = moneyReturn2;
}
double acceptCash(double money) override
{
if (money > moneyCondition)
return (money - floor(money / moneyCondition)*moneyReturn);//floor函数返回小于等于x(浮点数)的最大整数
else
return money;
}
};
(2)策略模式:StrategyContext
//策略模式
class CashContext
{
private:
CashSuper *cs = nullptr;
public:
CashContext(char type)
{
//将实例化具体策略的过程由客户端转移到策略中,简单工厂的应用
switch (type)
{
case 'A':
cs = new CashNormal();
break;
case 'B':
cs = new CashRebate(0.8);
break;
case 'C':
cs = new CashReturn(300, 100);
break;
default:
break;
}
}
double GetResult(double money)
{
return cs->acceptCash(money);
}
};
3 客户端代码:
//客户端代码
int main()
{
double total = 0;
cout << "请选择促销模式:\nA:正常销售(无任何优惠);\nB:打八折促销;\nC:返利模式(满300-100)" << endl;
char ch;
cin >> ch;
CashContext *cc = new CashContext(ch);
double totalPrice = 0;
vector<int> numVec;
vector<double> priceVec;
int num = 0;
double price = 0;
cout << "请输入物品的单价和数量【用空格隔开,ctrl+Z停止输入】" << endl;
while (cin >> price >> num)
{
numVec.push_back(num);
priceVec.push_back(price);
totalPrice += num*price;
cout << "请输入物品的单价和数量【用空格隔开,ctrl+Z停止输入】" << endl;
}
totalPrice = cc->GetResult(totalPrice);
auto it1 = numVec.cbegin();
auto it2 = priceVec.cbegin();
for (; it1 != numVec.cend() && it2 != priceVec.cend(); ++it1, ++it2)
{
cout << "数量:" << *it1 << "\t价格:" << *it2 <<endl;
}
cout << "合计:" << totalPrice << endl;
system("pause");
return 0;
}
请选择促销模式:
A:正常销售(无任何优惠);
B:打八折促销;
C:返利模式(满300-100)
A
请输入物品的单价和数量【用空格隔开,ctrl+Z停止输入】
200 3
请输入物品的单价和数量【用空格隔开,ctrl+Z停止输入】
100 3
请输入物品的单价和数量【用空格隔开,ctrl+Z停止输入】
20 3
请输入物品的单价和数量【用空格隔开,ctrl+Z停止输入】
^Z
数量:3 价格:200
数量:3 价格:100
数量:3 价格:20
合计:960
请按任意键继续. . .
请选择促销模式:
A:正常销售(无任何优惠);
B:打八折促销;
C:返利模式(满300-100)
B
请输入物品的单价和数量【用空格隔开,ctrl+Z停止输入】
200 2
请输入物品的单价和数量【用空格隔开,ctrl+Z停止输入】
30 4
请输入物品的单价和数量【用空格隔开,ctrl+Z停止输入】
^Z
数量:2 价格:200
数量:4 价格:30
合计:416
请按任意键继续. . .
请选择促销模式:
A:正常销售(无任何优惠);
B:打八折促销;
C:返利模式(满300-100)
C
请输入物品的单价和数量【用空格隔开,ctrl+Z停止输入】
100 3
请输入物品的单价和数量【用空格隔开,ctrl+Z停止输入】
20 4
请输入物品的单价和数量【用空格隔开,ctrl+Z停止输入】
^Z
数量:3 价格:100
数量:4 价格:20
合计:280
请按任意键继续. . .
注意:该程序运行时,将所有的C++源代码放入一个源文件中运行即可。
以下内容引自<http://blog.youkuaiyun.com/zhengzhb/article/details/7609670>,转载请注明出处!!!
卡奴达摩----策略模式
定义:定义一组算法,将每个算法都封装起来,并且使他们之间可以互换。
类型:行为类模式
类图:
策略模式是对算法的封装,把一系列的算法分别封装到对应的类中,并且这些类实现相同的接口,相互之间可以替换。在前面说过的行为类模式中,有一种模式也是关注对算法的封装——模版方法模式,对照类图可以看到,策略模式与模版方法模式的区别仅仅是多了一个单独的封装类Context,它与模版方法模式的区别在于:在模版方法模式中,调用算法的主体在抽象的父类中,而在策略模式中,调用算法的主体则是封装到了封装类Context中,抽象策略Strategy一般是一个接口,目的只是为了定义规范,里面一般不包含逻辑。其实,这只是通用实现,而在实际编程中,因为各个具体策略实现类之间难免存在一些相同的逻辑,为了避免重复的代码,我们常常使用抽象类来担任Strategy的角色,在里面封装公共的代码,因此,在很多应用的场景中,在策略模式中一般会看到模版方法模式的影子。
策略模式的结构
- 封装类:也叫上下文,对策略进行二次封装,目的是避免高层模块对策略的直接调用。
- 抽象策略:通常情况下为一个接口,当各个实现类中存在着重复的逻辑时,则使用抽象类来封装这部分公共的代码,此时,策略模式看上去更像是模版方法模式。
- 具体策略:具体策略角色通常由一组封装了算法的类来担任,这些类之间可以根据需要自由替换。
interface IStrategy {
public void doSomething();
}
class ConcreteStrategy1 implements IStrategy {
public void doSomething() {
System.out.println("具体策略1");
}
}
class ConcreteStrategy2 implements IStrategy {
public void doSomething() {
System.out.println("具体策略2");
}
}
class Context {
private IStrategy strategy;
public Context(IStrategy strategy){
this.strategy = strategy;
}
public void execute(){
strategy.doSomething();
}
}
public class Client {
public static void main(String[] args){
Context context;
System.out.println("-----执行策略1-----");
context = new Context(new ConcreteStrategy1());
context.execute();
System.out.println("-----执行策略2-----");
context = new Context(new ConcreteStrategy2());
context.execute();
}
}
策略模式的优缺点:
- 策略类之间可以自由切换,由于策略类实现自同一个抽象,所以他们之间可以自由切换。
- 易于扩展,增加一个新的策略对策略模式来说非常容易,基本上可以在不改变原有代码的基础上进行扩展。
- 避免使用多重条件,如果不使用策略模式,对于所有的算法,必须使用条件语句进行连接,通过条件判断来决定使用哪一种算法,在上一篇文章中我们已经提到,使用多重条件判断是非常不容易维护的。
策略模式的缺点:
- 维护各个策略类会给开发带来额外开销,可能大家在这方面都有经验:一般来说,策略类的数量超过5个,就比较令人头疼了。
- 必须对客户端(调用者)暴露所有的策略类,因为使用哪种策略是由客户端来决定的,因此,客户端应该知道有什么策略,并且了解各种策略之间的区别,否则,后果很严重。例如,有一个排序算法的策略模式,提供了快速排序、冒泡排序、选择排序这三种算法,客户端在使用这些算法之前,是不是先要明白这三种算法的适用情况?再比如,客户端要使用一个容器,有链表实现的,也有数组实现的,客户端是不是也要明白链表和数组有什么区别?就这一点来说是有悖于迪米特法则的。
适用场景
做面向对象设计的,对策略模式一定很熟悉,因为它实质上就是面向对象中的继承和多态,在看完策略模式的通用代码后,我想,即使之前从来没有听说过策略模式,在开发过程中也一定使用过它吧?至少在在以下两种情况下,大家可以考虑使用策略模式,
- 几个类的主要逻辑相同,只在部分逻辑的算法和行为上稍有区别的情况。
- 有几种相似的行为,或者说算法,客户端需要动态地决定使用哪一种,那么可以使用策略模式,将这些算法封装起来供客户端调用。