策咯-简单工厂模式结合------收银台程序

策咯模式

它定义了算法家族，分别封装起来，让它们之间可以互相替换，此模式让算法的变化，不会影响到使用算法的客户。

对于收银台程序，正常收费、打折收费、返利收费是三个具体策咯，也就是策咯模式中说的具体算法。

策咯-简单工厂模式结合——收银台程序代码具体实现：

//收银台程序
//现金收费基类
class CashSuper
{
public:
    virtual double acceptCash(double money);        //虚函数 用来实现多态
};

double CashSuper:: acceptCash(double money)
{
    return money;
}


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

//打折收费子类
class CashRebate : public CashSuper
{
public:
    CashRebate(double moneyRebate) :m_moneyRebate(moneyRebate){}
    double acceptCash(double money){ return money*m_moneyRebate; }
private:
    double m_moneyRebate;
};

//返利收费子类
class CashReturn :public CashSuper
{
public:
    CashReturn(int momeyCondtion, int moneyReturn):m_moneyCondition(momeyCondtion), m_moneyReturn(moneyReturn){}
    double acceptCash(double money)
    {
        double result = money;
        if (money >= m_moneyCondition)
            result = money - (money / m_moneyCondition * m_moneyReturn);

        return result;
    }
private:
    double m_moneyCondition;
    double m_moneyReturn;
};

//现金收费工厂类
//用于创建不同的对象，如：正常收费类的对象、折扣收费类的对象及满减收费类的对象。
class CashFactory
{
public:
    static CashSuper* createCashAccept(size_t type);
};

//简单工厂模式和策咯模式相结合
class CashContext
{
public:
    CashContext(size_t type);
    double GetResult(double money){ return m_cs->acceptCash(money); }
private:
    CashSuper *m_cs;
};

CashContext::CashContext(size_t type)
{
    switch (type)
    {
        //正常收费
    case 0:
        m_cs = new CashNormal();
        break;
        //打八折
    case 1:
        m_cs = new CashRebate(0.8);
        break;
        //满三百减一百
    case 2:
        m_cs = new CashReturn(300, 100);
        break;
    default:
        break;
        //在需要其他收费规则时，只需要在这里添加创建对象的方法，若过需要创建的对象是上面写的三个类之外的对象，可以先写一个新方法的类，然后在这里创建新的对象
    }
}

测试程序：

int main()
{
    CashContext Cashcontext(1);     // 1代表打八折
    cout << "打八折：";
    cout << Cashcontext.GetResult(1000) << endl;

    CashContext Cashcontext2(2);        // 2代表满三百减一百
    cout << "满三百减一百：";
    cout << Cashcontext2.GetResult(1000) << endl;

    system("pause");

    return 0;
}

运行结果：

总结

• 简单工厂模式我需要客户端认识连个类，CashSuper 和 CashFactory，而策咯模式于简单工厂结合的用法，客户端只需要认识一个类CashContext就可以了，耦合更加降低。

  • 策咯模式是一种定义一系列算法的方法，从概念上来看，所有这些算法完成的都是相同的工作，只是实现不同，它可以以相同的方式调用所有的算法，减少各种算法类与使用算法类之间的耦合

策咯模式的优点

• 策咯模式的 Strategy 类层次为Context定义了一系列的可供重用的算法或行为。继承有助于析取出这些算法中的公共功能
• 简化了单元测试，因为每个算法都有自己的类，可以通过自己的接口单独测试。
• 策咯模式就是用来封装算法的，但是在实践中，发现可以用它来封装几乎任何类型的规则，只要在分析过程中听到需要在不同时间应用不同的业务规则，就可以考虑使用策咯模式处理这种变化的可能性。