【设计模式】商场促销 -- 策略模式

最新推荐文章于 2020-04-09 14:57:30 发布
最新推荐文章于 2020-04-09 14:57:30 发布
阅读量3.2k 收藏 1
点赞数 2
分类专栏： 【设计模式】 文章标签： 设计模式 class 算法 string c# c
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/tianshuai1111/article/details/7671823
版权

一，概念

        策略模式定义了一系列的算法，并将每一个算法封装起来，而且使它们还可以相互替换。策略模式让算法独立于使用它的客户而独立变化。

二，策略模式的组成

　　 1）抽象策略角色： 策略类，通常由一个接口或者抽象类实现。
　　 2）具体策略角色：包装了相关的算法和行为。

　　 3）环境角色：持有一个策略类的引用，最终给客户端调用。

三，补充C++知识

类对象的构造顺序是这样的：
  1.分配内存，调用构造函数时，隐式／显示的初始化各数据成员
  2.进入构造函数后在构造函数中执行一般计算
       1）类里面的任何成员变量在定义时是不能初始化的。
       2）一般的数据成员可以在构造函数中初始化。
       3）const数据成员必须在构造函数的初始化列表中初始化。
       4）static要在类的定义外面初始化。  
       5）数组成员是不能在初始化列表里初始化的。
       6）不能给数组指定明显的初始化。 
这6条一起，说明了一个问题：C++里面是不能定义常量数组的！因为3和5的矛盾。这个事情似乎说不过去啊？没有办法，我只好转而求助于静态数据成员。
到此，我的问题解决。但是我还想趁机复习一下C++类的初始化：
  1.初始化列表：CSomeClass::CSomeClass() : x(0), y(1){}
  2.类外初始化：int CSomeClass::myVar=3;
  3.const常量定义必须初始化，C++类里面使用初始化列表;
  4.C++类不能定义常量数组。

在C++类中，必须做如下事情：

1.必须对任何const或引用类型成员以及没有默认构造函数的 类 类型 的任何成员 显示地使用初始化列表进行初始化

2.类成员在定义时是不能被初始化的。

3.类的成员初始化顺序与成员变量在构造函数中的位置选后顺序无关，至于成员变量在类中定义的先后顺序有关。

C++默认继承方式为private

C++ new 生成的对象为指针，所以new 前面的对象要声明为指针类型

四，实例

        计算器简单工厂模式的精简实现

#include <iostream>
using namespace std;

class COperation//基类
{
public:
	int m_nFirst;
	int m_nSecond;
	virtual double GetResult()
	{
		double dResult=0;
		return dResult;
	}
};

class AddOperation : public COperation//加法
{
public:
	virtual double GetResult()
	{
		return m_nFirst+m_nSecond;
	}
};

class SubOperation : public COperation//减法
{
public:
	virtual double GetResult()
	{
		return m_nFirst-m_nSecond;
	}
};


class CCalculatorFactory//工厂类
{
    
public://静态方法属于类本身，不属于哪个对象 
	static COperation* Create(char cOperator);

};

COperation* CCalculatorFactory::Create(char cOperator)//工厂类的实现
{
	COperation *oper;
	
    //在C#中可以用反射来取消判断时用的switch，在C++中用什么呢？RTTI？？
	switch (cOperator)
	{
		case '+':
			oper=new AddOperation();
		     break;
		case '-':
			oper=new SubOperation();
            break;
		default:
			oper=new AddOperation();
	     	break;
	}
	return oper;
}

int main()
{
	int a,b;
	cin>>a>>b;
	
	/*静态方法为类所有，可以通过对象来使用，也可以通过类来使用。
	但一般提倡通过类名来使用，因为静态方法只要定义了类，不必建立类的实例就可使用*/
	COperation * op = CCalculatorFactory::Create('-');//静态方法调用方式 
	op->m_nFirst=a;
	op->m_nSecond=b;
	cout<<op->GetResult()<<endl;
	return 0;
}

将简单工厂模式优化为策略模式后的代码如下： 

#include <iostream>
using namespace std; 

//策略基类
class COperation
{
public:
	int m_nFirst;
	int m_nSecond;
	virtual double GetResult()
	{
		double dResult=0;
		return dResult;
	}
};

//策略具体类-加法类
class AddOperation : public COperation
{
public:
	AddOperation(int a,int b)
	{
		m_nFirst=a;
		m_nSecond=b;
	}
	virtual double GetResult()
	{
		return m_nFirst+m_nSecond;
	}
};

class Context//策略类 
{
private:
	COperation* op;
public:
    Context(COperation* temp)//参数为策略基类（传递的时候被初始化为子类） 
	{
        op=temp;
	}
	double GetResult()
	{
		return op->GetResult();
	}
};

//客户端
int main()
{
	int a,b;
    char c;
	cin>>a>>b;
    cout<<"请输入运算符：";
    cin>>c;
    switch(c)
    {
       case '+':
	        Context *context=new Context(new AddOperation(a,b));
     	        cout<<context->GetResult()<<endl;
            break;
       default:
            break;
    }
	return 0;
}

这里将策略（操作符）封装成一个Context类，通过传递操作符子对象来返回相应子对象下操作结果。

菜鸟实现工厂模式和策略模式

        客户端只需访问Context类，而不用知道其它任何类信息，实现了低耦合。在上例基础上，修改下面内容

#include <iostream>
using namespace std;
 
 
 //策略基类
class COperation
{
public:
	int m_nFirst;
	int m_nSecond;
	virtual double GetResult()
	{
		double dResult=0;
		return dResult;
	}
};

//策略具体类-加法类
class AddOperation : public COperation
{
public:
	AddOperation(int a,int b)
	{
		m_nFirst=a;
		m_nSecond=b;
	}
	AddOperation()
	{
		m_nFirst=0;
		m_nSecond=0;
	}
	virtual double GetResult()
	{
		return m_nFirst+m_nSecond;
	}
};
class Context
{
private:
	COperation* op;
public:
    Context(char cType)
	{
        switch (cType)
        {
		case '+':
			op=new AddOperation(3,8);
			break;
		default:
			op=new AddOperation();
			break;
        }
	}
	double GetResult()
	{
		return op->GetResult();
	}
};
//客户端
int main()
{
	Context *test=new Context('+');
	cout<<test->GetResult()<<endl;
	return 0;
}

五，商场促销例子

        这里想说的是，abstract 关键字是微软为C#定义的，抽象类关键字。C++中没有抽象类，如果想成为抽象类在类中定义纯虚函数就可以了。只要拥有纯虚函数的类就是抽象类，由于抽象类包含了没有定义的纯虚函数，所以不能定义抽象类的对象。

         商场促销的简单工厂实现：

#include <iostream>

using namespace std;

class CashSuper //现金收费抽象类
{
public:
    virtual double acceptCash(double money)//不能设置为纯虚函数，后面还要生成对象用呢！！！！ (不能只定义，而不实现)
    {
        
    }
};

class CashNormal : public CashSuper //收费子类，正常收费
{
public:
     double acceptCash(double money)
     {
         return money;
     }
    
};

class CashRebate : public CashSuper //打折收费子类
{
private:
    double moneyRebate;//不允许初始化
public:
    CashRebate(double moneyRebate)
    {
        this->moneyRebate=moneyRebate;
    }
    double acceptCash(double money)
    {
         return money*moneyRebate;
    }
};

class CashReturn :public CashSuper //返利收费子类（默认继承为私有继承）
{
private:
    double moneyCondition ;//返利购买额度
    double moneyReturn ;//返利多少
public:
    CashReturn(double moneyCondition,double moneyReturn)
    {
        this->moneyCondition=moneyCondition;
        this->moneyReturn=moneyReturn;
    }
    double acceptCash(double money)
    {
        double result = money;
        if(money >= moneyCondition )
            result = money-(money/moneyCondition)*moneyReturn;
        return result;
        
    }
};

class CashFactory
{
public:
    static CashSuper* creatCashAccept(string type)//根据子类type来生成相应收费子类
    {
        CashSuper *cs;
        if(type=="CashNormal")
            cs=new CashNormal();
        else if(type == "CashRebate")
            cs=new CashRebate(0.8);
        else if(type == "CashReturn")
            cs=new CashReturn(300,100);
        
        return cs;
    }
};

int main(int argc, char** argv) {

    CashSuper *csuper = CashFactory::creatCashAccept("CashRebate");
    double result=csuper->acceptCash(500);//500打八折，应该输出 400
    cout<<"CashRebate 500 is："<<result<<endl;
    return 0;
}

    策略模式：定义了算法家族，分别封装起来，让它们之间可以相互替换，算法的变化不会影响使用算法的客户。
        主要升级就是，将算法封装到Context中，然后通过传递对象生成相应子类对象，然后得到结果。 

#include <iostream>

using namespace std;

class CashSuper //现金收费抽象类
{
public:
    virtual double acceptCash(double money)//不能设置为纯虚函数，后面还要生成对象用呢！！！！ 
    {
        
    }
};

class CashNormal : public CashSuper //收费子类，正常收费
{
public:
     double acceptCash(double money)
     {
         return money;
     }
    
};

class CashRebate : public CashSuper //打折收费子类
{
private:
    double moneyRebate;//不允许初始化
public:
    CashRebate(double moneyRebate)
    {
        this->moneyRebate=moneyRebate;
    }
    double acceptCash(double money)
    {
         return money*moneyRebate;
    }
};

class CashReturn :public CashSuper //返利收费子类（默认继承为私有继承）
{
private:
    double moneyCondition ;//返利购买额度
    double moneyReturn ;//返利多少
public:
    CashReturn(double moneyCondition,double moneyReturn)
    {
        this->moneyCondition=moneyCondition;
        this->moneyReturn=moneyReturn;
    }
    double acceptCash(double money)
    {
        double result = money;
        if(money >= moneyCondition )
            result = money-(money/moneyCondition)*moneyReturn;
        return result;
        
    }
};

/*class CashFactory
{
public:
    static CashSuper* creatCashAccept(string type)//根据子类type来生成相应收费子类
    {
        CashSuper *cs;
        if(type=="CashNormal")
            cs=new CashNormal();
        else if(type == "CashRebate")
            cs=new CashRebate(0.8);
        else if(type == "CashReturn")
            cs=new CashReturn(300,100);
        
        return cs;
    }
};*/

class CashContext
{
private:
    CashSuper cs;
public:
    CashContext(CashSuper csuper)
    {
        this->cs=csuper;
    }
    double GetResult(double money)
    {
        return cs.acceptCash(money);
    }
};

int main(int argc, char** argv) {

    //CashSuper *csuper = CashFactory::creatCashAccept("CashRebate");
    //double result=csuper->acceptCash(500);//500打八折，应该输出 400
    
    
     CashContext *cs;
     string type="CashRebate";
     
     if(type=="CashNormal")
            cs=CashContext(new CashNormal());
     else if(type == "CashRebate")
            cs=CashContext(new CashRebate(0.8));
     else if(type == "CashReturn")
            cs=CashContext(new CashReturn(300,100));
        
        
    cout<<"CashRebate 500 is"<<cs->GetResult(500)<<endl;
    return 0;
}

这样仍然存在缺点：就是让客户端来判断生成哪个子类。

改进策略是，让策略模式和工厂模式结合

#include <iostream>

using namespace std;

class CashSuper //现金收费抽象类
{
public:
    virtual double acceptCash(double money)//不能设置为纯虚函数，后面还要生成对象用呢！！！！ 
    {
        
    }
};

class CashNormal : public CashSuper //收费子类，正常收费
{
public:
     double acceptCash(double money)
     {
         return money;
     }
    
};

class CashRebate : public CashSuper //打折收费子类
{
private:
    double moneyRebate;//不允许初始化
public:
    CashRebate(double moneyRebate)
    {
        this->moneyRebate=moneyRebate;
    }
    double acceptCash(double money)
    {
         return money*moneyRebate;
    }
};

class CashReturn :public CashSuper //返利收费子类（默认继承为私有继承）
{
private:
    double moneyCondition ;//返利购买额度
    double moneyReturn ;//返利多少
public:
    CashReturn(double moneyCondition,double moneyReturn)
    {
        this->moneyCondition=moneyCondition;
        this->moneyReturn=moneyReturn;
    }
    double acceptCash(double money)
    {
        double result = money;
        if(money >= moneyCondition )
            result = money-(money/moneyCondition)*moneyReturn;
        return result;
        
    }
};

/*class CashFactory
{
public:
    static CashSuper* creatCashAccept(string type)//根据子类type来生成相应收费子类
    {
        CashSuper *cs;
        if(type=="CashNormal")
            cs=new CashNormal();
        else if(type == "CashRebate")
            cs=new CashRebate(0.8);
        else if(type == "CashReturn")
            cs=new CashReturn(300,100);
        
        return cs;
    }
};*/

class CashContext
{
private:
    CashSuper cs;
public:
    CashContext(string type)
    {
        if(type=="CashNormal")
            this->cs=new CashNormal();
        else if(type == "CashRebate")
            this->cs=new CashRebate(0.8);
        else if(type == "CashReturn")
            this->cs=new CashReturn(300,100);
              
    }
    double GetResult(double money)
    {
        return cs.acceptCash(money);
    }
};

int main(int argc, char** argv) {

     CashContext *cs=new CashContext("CashRebate");
           
     cout<<"CashRebate 500 is"<<cs->GetResult(500)<<endl;
    return 0;
}

这样客户端只需要更改金额和打折手段就可以了。相对简单工厂的提升为：简单工厂需要让客户调用两个类SuperCash和CashFactory。而结合之后仅仅需要调用CashContext就可以了

相对与策略模式的提升为：客户端需要承担的判断更少了，更简洁了


策略模式--商场促销_设计模式.rar
12-25
面向对象的编程，并不是类越多越好，类的划分是为了封装，但分类的基础是抽象，具有相同属性和功能的对象的抽象集合才是类 策略模式：它定义了算法家族，分别封装起来，让它们之间可以相互替换，此模式让算法的变化，不会影响到使用算法的客户
《大话设计模式》之--第2章 商场促销----策略模式
thinkinwm的专栏
06-12 1694
http://blog.csdn.net/monkey_d_meng/article/details/5681174 第2章 商场促销----策略模式 2.1商场收银软件        “小菜，给你出个作业，做一个商场收银软件，营业员根据客户所购买商品的单价和数量，向客户收费。”        “就这个？木问题。”小菜说，“用两个文本框来输入单价和数量，一个确定按键来算出每
设计模式之二 商场促销-策略模式
Huaerge的专栏
10-24 2217
   策略模式是一种定义一系列算法的方法，从概念上来看，所有这些算法完成的都是相同的工作，只是实现不同，它可以以相同的方式调用所有的算法，减少了各种算法类与使用算法类之间的耦合。   策略模式（Strategy）：它定义了算法家族，分别封装起来，让它们之间可以互相替换，此模式让算法的变化，不会影响到使用算法的客户。   当不同的行为堆砌在一个类中时，就很难避免使用条件语句来选择合适的行为。将这些行为封装在一个个独立的Strategy类中，可以在使用这些行为的类中消除条件语句。    代码写完之后，感觉它与简
大话设计模式策略模式_多种方法实现商场促销
u013905744的专栏
02-20 1031
大话设计模式策略模式_多种方法实现商场促销
人人都会设计模式---策略模式--Strategy
01-27
【策略模式】是一种设计模式，它的核心思想是将不同的算法或行为封装成独立的类，这些类具有统一的接口，从而使客户端可以灵活地选择并使用其中的任何一种算法，而无需关心具体实现的细节。这种模式可以有效地避免...
Java使用策略模式解决商场促销商品问题示例
08-27
策略模式是软件设计模式中的一种行为型模式，用于定义一系列的算法，将每一种算法封装起来，并可以相互替换使用。策略模式让算法独立于使用它的客户应用而独立变化。 在商场促销商品问题中，策略模式可以用来解决...
Java设计模式教程-策略模式Java开发Java经验技
最新发布
12-01
策略模式是Java设计模式中的一种行为模式，它允许在运行时改变对象的行为。在Java开发过程中，策略模式常被用来封装一系列算法，并使它们可以互相替换，从而使算法的变化独立于使用算法的客户。这种模式的核心在于...
大话模式源代码-02策略模式
07-22
策略模式是一种行为设计模式，它使你能在运行时改变对象的行为。在软件开发中，我们经常遇到需要根据不同的条件或时间点执行不同算法的情况。策略模式允许我们将这些算法封装成独立的类，使得它们可以互换，从而提高...
商场促销—策略模式
杨月娥
12-07 2840
总算是看完了一遍《大话设计模式》，到了实践的时候了。对于初学C#的我来说，真的是遇到了一些困难，怎么一打开代码编写窗口，都不知道从哪行开始写代码，非常错乱的感觉。但是经过这半个月的学习与实践，这些问题也不再是问题了。     从附录A就开始敲书上的例子，到现在进行的策略模式，我也算是得到了一些经验。     策略模式（strange）：它定义了算法家族，分别封装起来，让它们之间可以相互替换，此
用Java写的一个购物系统
08-06
用Java写的一个基于EJB框架的购物系统。
java商场打折系统
05-03
这是软件工程课程里要求的商场打折系统，我用mysql作为数据库，如果你有一点java和mysql基础应该是可以看懂的，
二、策略模式-商场促销活动
weixin_30641999的博客
11-20 304
以商场收银为例，理解并实践“策略模式”。 简单商场促销活动描述：营业员提供商品单价、数量、商场目前的活动（满减、打折等），计算用户最终需要支付的金额。 一、面向过程的实现方式 1 package secondStrategy; 2 import java.text.DecimalFormat; 3 public class StrategyTest { 4 ...
商场促销 --- 策略模式
Eagle407
11-09 992
一，概念         策略模式定义了一系列的算法，并将每一个算法封装起来，而且使它们还可以相互替换。策略模式让算法独立于使用它的客户而独立变化。 二，策略模式的组成 　　 1）抽象策略角色： 策略类，通常由一个接口或者抽象类实现。 　　 2）具体策略角色：包装了相关的算法和行为。 　　 3）环境角色：持有一个策略类的引用，最终给客户端调用。 三，补充C+
大话设计模式02----商场促销-策略模式
烽火前秦路
07-20 1210
1 策略模式UML图 2 策略模式的概念 策略模式（Strategy）：塔定义了算法家族，分别封装起来，让它们之间可以相互替换，此模式让算法的变化，不会影响到算法的客户。【DP】 3 策略模式和简单工厂模式的比较 简单工厂模式需要让客户端认识两个类，而策略模式和简单工厂结合的用法，客户端就只需要认识一个类就可以了，耦合度更低。 4 策略模式解析
C++设计模式学习笔记：策略模式
zcd1023的博客
11-18 224
设计模式：策略模式策略模式设计商场促销介绍功能快捷键合理的创建标题，有助于目录的生成如何改变文本的样式插入链接与图片C++代码生成一个适合你的列表创建一个表格设定内容居中、居左、居右SmartyPants创建一个自定义列表如何创建一个注脚注释也是必不可少的KaTeX数学公式新的甘特图功能，丰富你的文章UML 图表FLowchart流程图导出与导入导出导入 策略模式设计商场促销 介绍 商场促销： ...
【经典案例】Python详解设计模式：策略模式
04-09 286
完成一项任务往往有多种方式，我们将其称之为策略。 比如，超市做活动，如果你的购物积分满1000，就可以按兑换现金抵用券10元，如果购买同一商品满10件，就可以打9折，如果如果购买的金额超过500，就可以享受满减50元的优惠。这是三个不同的促销策略。 再比如，联系朋友、同学，可以打电话，也可以发短信，可以发微信，也可以发邮件，这是四个不同的联系策略。 再比如，去外出旅游，我们可以选择火车，也可以选择...
策略模式应用之商场收费系统(C#源代码)
11-14 1194
using System;namespace CashSystem{    //线程类    class CRunMain    {        public static void ShowMessage()        {            Console.WriteLine("-----------------please input your choise: -----------
23种设计模式-策略模式《商家打折》
热门推荐
yancyang的博客
07-20 2万+
对于许久不用的东西，容易忘记。百度许久，也未能找到自己所要。 从今日起，有些东西就记载下来，不仅方便自己，希望能帮到他人吧 最近开发一款电商App，对于商家推出的活动焦头烂额，好歹想起了设计模式中的策略模式，从容的解决这种问题。 商家的活动： 1.满100减10元。 2.三件8.5折。 3.五件送一件最近价格商品。 … 最开始使用swich，后来越来越多case，代码繁杂...
Java策略模式实战：商场促销策略实现
"Java使用策略模式解决商场促销商品问题示例" ...策略模式在解决商场促销商品问题上表现出色，它允许我们在不修改现有代码的情况下，灵活地插入新的促销策略，符合开闭原则，增强了程序的可维护性和可扩展性。
评论 3
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值