大话设计模式02----商场促销-策略模式

大话设计模式


1 策略模式UML图


2 策略模式的概念


策略模式(Strategy):它定义了算法家族,分别封装起来,让它们之间可以相互替换,此模式让算法的变化,不会影响到算法的客户。【DP】


3 策略模式和简单工厂模式的比较


简单工厂模式需要让客户端认识两个类,而策略模式和简单工厂结合的用法,客户端就只需要认识一个类就可以了,耦合度更低。

4 策略模式解析

  1. 策略模式是一种定义一系列算法的方法,从概念上来看,所有这些算法完成的都是相同的工作,只是实现不同,他可以以相同的方式调用所有的算法,减少了各种算法类与使用算法类之间的耦合。【DPE】
  2. 策略模式的Strategy类层次为Context定义了一些列的可供重用的算法或行为。集成有助于析取出这些算法中的公共功能。【DP】
  3. 策略模式简化了单元测试,因为每个算法都有自己的类,可以通过自己的接口单独测试。【DPE】
  4. 当不同的行为堆砌在一个类中时,就很难避免使用条件语句来选择合适的行为。将这些行为封装在一个个独立的Strategy类中,可以在使用这些行为的类中消除条件语句。【DP】。如收费系统中,客户端出去了条件语句,避免了判断。
  5. 策略模式就是用来封装算法的。
  6. 只要在分析过程中听到需要在不同时间应用不同的业务规则,就可以考虑使用策略模式处理这种变化的可能性。
  7. 在基本的策略模式中,选择所用具体实现的职责由客户端对象承担,并转给策略模式的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;
}

运行结果1:
请选择促销模式:
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
请按任意键继续. . .

运行结果2:
请选择促销模式:
A:正常销售(无任何优惠);
B:打八折促销;
C:返利模式(满300-100)
B
请输入物品的单价和数量【用空格隔开,ctrl+Z停止输入】
200 2
请输入物品的单价和数量【用空格隔开,ctrl+Z停止输入】
30 4
请输入物品的单价和数量【用空格隔开,ctrl+Z停止输入】
^Z
数量:2 价格:200
数量:4 价格:30
合计:416
请按任意键继续. . .


运行结果3:
请选择促销模式:
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.csdn.net/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个,就比较令人头疼了
  • 必须对客户端(调用者)暴露所有的策略类,因为使用哪种策略是由客户端来决定的,因此,客户端应该知道有什么策略,并且了解各种策略之间的区别,否则,后果很严重。例如,有一个排序算法的策略模式,提供了快速排序、冒泡排序、选择排序这三种算法,客户端在使用这些算法之前,是不是先要明白这三种算法的适用情况?再比如,客户端要使用一个容器,有链表实现的,也有数组实现的,客户端是不是也要明白链表和数组有什么区别?就这一点来说是有悖于迪米特法则的。

适用场景

做面向对象设计的,对策略模式一定很熟悉,因为它实质上就是面向对象中的继承和多态,在看完策略模式的通用代码后,我想,即使之前从来没有听说过策略模式,在开发过程中也一定使用过它吧?至少在在以下两种情况下,大家可以考虑使用策略模式,

  • 几个类的主要逻辑相同,只在部分逻辑的算法和行为上稍有区别的情况。
  • 有几种相似的行为,或者说算法,客户端需要动态地决定使用哪一种,那么可以使用策略模式,将这些算法封装起来供客户端调用。
策略模式是一种简单常用的模式,我们在进行开发的时候,会经常有意无意地使用它,一般来说,策略模式不会单独使用,跟模版方法模式、工厂模式等混合使用的情况比较多。






本页内容版权归属为原作者,如有侵犯您的权益,请通知我们删除。
在Java多线程应用中,队列的使用率很高,多数生产消费模型的首选数据结构就是队列。Java提供的线程安全的Queue可以分为 阻塞队列和非阻塞队列 ,其中阻塞队列的典型例子是BlockingQueue,非阻塞队列的典型例子是ConcurrentLinkedQueue,在实际应用中要根据实际需要选用阻塞队列或者非阻塞队列。 注:什么叫 线程安全 ?这个首先要明确。 线程安全的类  ,指的是 类内共享的全局变量的访问必须保证是 不受多线程形式影响的 。如果由于多线程的访问(比如修改、遍历、查看)而使这些变量结
偿还技术债 - 通过重构拯救老代码 尝试去接管一个陈旧的代码库使他成为达成一个可控的状态? 这几年的大型的旧web应用程序开发给了我们如下这些建议。 通过重构去拯救旧代码 松鼠会因为忘记自己把松果放在那里,使得每年多了几千棵松树。类似的,这些事情在项目中都没有什么关系。 你的项目是可以被拯救的 无论代码多么的杂乱,让人疯狂。 但是你的老板让你上了,你要相信不管前路多么曲折坎坷,你总能搞定的! 心无畏惧 公平的说。比起冲进一个四处鲜血还有巨龙守在门口的沼泽地待几年,你更愿意在一片清新的草原上散步。 不幸的是

hibernate缓存详解 - 2016-07-22 18:07:56

为什么要用hibernate缓存? hibernate是一个 持久层框架 ,经常访问物理数据库。为了降低应用程序对物理数据源访问的次数,从而提高应用程序的运行性能,我们想到使用hibernate缓存机制。缓存内的数据是对物理数据源中的数据的复制,应用程序在运行时从缓存读写数据,在特定的时刻或事件会同步缓存和物理数据源的数据。 hibernate缓存的原理 缓存的主要作用是查询 。 hibernate缓存包括三大类: hibernate一级缓存、hibernate二级缓存和hibernate查询缓存 。 一

MAT使用的几张图例 - 2016-07-22 18:07:51

下面三个是内存泄漏可能性比较大的地方 problem suspect 1 problem suspect 2 problem suspect 3 点击detail 可以看详细 在dominator_tree 可以对象按照group by package 分类 便于查看那部分代码出问题 选中一个节点 右键查看with incoming reference 可以看  ps :( ListObjects with incoming references  表示的是 当前查看的对象,被外部应用 ListObjec

Hibernate的核心接口和类 - 2016-07-22 18:07:25

Hibernate的核心类和接口一共有6个,分别为: Session、SessionFactory、 Transaction、Query、Criteria和Configuration 。这6个核心和类接口在任何开发中都会用到。通过这些接口,不仅可以对持久化对象进行存取,还能够进行事务控制。下面对这6个核心接口和类分别加以介绍。 Configuration Configuration类的作用是对Hibernate进行配置,以及对它进行启动。在Hibernate的启动过程中,Configuration 类的实
1、概述 在我开始构思这几篇关于“自己动手设计ESB中间件”的文章时,曾有好几次动过放弃的念头。原因倒不是因为对冗长的文章产生了惰性,而是ESB中所涉及到的技术知识和需要突破的设计难点实在是比较多,再冗长的几篇博文甚至无法对它们全部进行概述,另外如果在思路上稍微有一点差池就会误导读者。 一个可以稳定使用的ESB中间件凝聚了一个团队很多参与者的心血,一个人肯定是无法完成这些工作的 。但是笔者思索再三,还是下决心将这这即便文章完成,因为这是对本专题从第19篇文章到第39篇文章中所介绍的知识点的最好的总结。我们
1、Exactly_once简介 Exactly_once语义是Flink的特性之一,那么Flink到底提供了什么层次的Excactly_once?有人说是是每个算子保证只处理一次,有人说是每条数据保证只处理一次。其实理解这个语义并不难,直接在官方文档中就可以看出: 从图中可以看出:Exactly_once是为有状态的计算准备的! 换句话说,没有状态的算子操作(operator),Flink无法也无需保证其只被处理Exactly_once!为什么无需呢?因为即使失败的情况下,无状态的operator(ma
简单工厂模式是指专门定义一个类来负责创建其他类的实例,被创建的实例通常都具有共同的父类。 从图中我们可以清楚的看到,该模式中主要包含下面3种 角色: 工厂(Creator)角色 它是工厂模式的核心,负责实现创建所有势力的内部逻辑。工厂类可以被外界直接调用,创建所需的产品的对象。 抽象(Product)角色 简单工厂模式所创建的所有对象的父类,负责描述所有实例所共有的公共接口。 具体产品(Concrete Product)角色 是该模式的创建目标,所有创建的对象都是充当这个角色的某个具体类的实例。一般来讲是

Mybatis学习第一天 - 2016-07-22 17:07:07

  Mybatis第一天 2      MyBatis介绍 MyBatis 本是apache的一个开源项目iBatis, 2010年这个项目由apache software foundation迁移到了google code,并且改名为MyBatis 。2013年11月迁移到Github。 MyBatis是一个优秀的持久层框架,它对jdbc的操作数据库的过程进行封装,使开发者只需要关注 SQL 本身,而不需要花费精力去处理例如注册驱动、创建connection、创建statement、手动设置参数、结果集

IP数据报的分片和组装过程 - 2016-07-22 17:07:07

        一份数据从一个主机通过以太网发送到里一个主机时,是要经过很多层路由转发的。其中过程相对比较的复杂,在这里我们要讨论的是IP在路由中转发时是以怎样的形式转发的和目的主机在接受到这写数据报时又是怎样处理的。        首先我们需要了解的是整个 IP数据报的格式 : IP的转发控制都是由IP数据报的头部决定的。在这里我们就不详细的讨论首部的所有字段,我们就讨论一下个分片有关的总长度字段。        在IP数据报中,总长度是16位的字段,依次数据报的最大长度为2^16-1=65535字节,