大话设计模式之策略模式

第二章:商场促销——策略模式

策略模式的定义:

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

策略模式的优点 :

1. 策略模式的Strategy 类层次为Context定义了一些列的可供重用的算法或行为。继承有助于析取这些算法中的公共功能

2.简化了单元测试,因为每个算法都要自己的类,可以通过自己的接口单独测试

当不同的行为堆砌在一个类中时,就很难避免使用条件语句来选择合适的行为,将这些行为封装在一个个独立的Strategy类中,可以在使用这些行为的类中消除条件语句

策略模式就是用来封装算法的,但是在实践中,我们发现可以用它来封装几乎任何类型的规则,只要在分析过程中听到需要在不同实践应用不同的业务规则,就可以考虑使用策略模式处理这种变化的可能性

在基本的策略模式中,选择所用具体实现的职责有客户端对象承担,并转给策略模式的Context对象

父类CashSuper

CashSuper.h

@interface CashSuper : NSObject
-(double)acceptCash:(double)money;
@end

CashSuper.m

@implementation CashSuper

-(double)acceptCash:(double)money{

return money;

}

@end

正常消费类 CashNormal

CashNormal.h

#import <Foundation/Foundation.h>
#import "CashSuper.h"
@interface CashNormal : CashSuper

@end

CashNormal.m

#import "CashNormal.h"

@implementation CashNormal
-(double)acceptCash:(double)money{

    return money;
}
@end

打折消费类CashRebate

CashRebate.h

#import <Foundation/Foundation.h>
#import "CashSuper.h"
@interface CashRebate : CashSuper
@property(assign,nonatomic)double Rebate;
-(instancetype)initWithRebate:(double) Rebate;
@end

CashRebate.m

#import "CashRebate.h"

@implementation CashRebate
- (instancetype)initWithRebate:(double)Rebate{
    self = [super init];
    if (self) {
        _Rebate=Rebate;
    }
    return self;
}
-(double)acceptCash:(double)money{

    return money*_Rebate;
}
@end

返利消费类CashReturn

CashReturn.h

#import <Foundation/Foundation.h>
#import "CashSuper.h"
@interface CashReturn : CashSuper
@property(assign,nonatomic)double moneyCondition;
@property(assign,nonatomic)double moneyReturn;
-(instancetype)initWithMoneyCondition:(double)moneyCondition :(double)moneyReturn;
@end

CashReturn.m

#import "CashReturn.h"

@implementation CashReturn
-(instancetype)initWithMoneyCondition:(double)moneyCondition :(double)moneyReturn
{
    self = [super init];
    if (self) {
        _moneyCondition=moneyCondition;
        _moneyReturn=moneyReturn;
    }
    return self;
}
-(double)acceptCash:(double)money{
    double result=money;
    if (money>=_moneyCondition) {
        result=money-((int)(money/_moneyCondition))*_moneyReturn;
    }
    return result;
}
@end

配置类,维护对对象的使用CashContext类

CashContext.h

#import <Foundation/Foundation.h>
#import "CashSuper.h"
@interface CashContext : NSObject
@property(nonatomic,strong)CashSuper *cashsuper;
-(instancetype)initWith:(CashSuper *)csuper;
-(double)GetResult:(double)money;
@end

CashContext.m

#import "CashContext.h"

@implementation CashContext
- (instancetype)initWith:(CashSuper *)csuper
{
    self = [super init];
    if (self) {
        _cashsuper=csuper;
    }
    return self;
}
-(double)GetResult:(double)money{
   return  [_cashsuper acceptCash:money];

}
@end

主函数

#import <Foundation/Foundation.h>
#import "CashContext.h"
#import "CashSuper.h"
#import "CashNormal.h"
#import "CashRebate.h"
#import "CashReturn.h"
int main(int argc, const char * argv[]) {
    @autoreleasepool {
        char type=‘B‘;
        double result=0.0;
        CashContext *cc=nil;

        switch (type) {
            case ‘N‘:

                cc=[[CashContext alloc]initWith:[[CashNormal alloc]init]];
                break;
            case ‘B‘:

                cc=[[CashContext alloc]initWith:[[CashRebate alloc]initWithRebate:0.7]];
                break;
            case ‘T‘:
                cc=[[CashContext alloc]initWith:[[CashReturn alloc] initWithMoneyCondition:300 :100]];
                break;
        }
        result = [cc GetResult:500];
        NSLog(@"%f",result);
    }
    return 0;
}

运行打折类

时间: 2024-11-08 23:30:47

大话设计模式之策略模式的相关文章

大话设计模式_策略模式(Java代码)

策略模式:定义算法家族,分别封装,让它们之间可以互相替换,此模式让算法的变化不会影响到使用算法的客户 简单描述:一个父类,多个子类实现具体方法.一个Context类持有父类的引用(使用子类实例化此引用),客户端代码只需要与此Context类交互即可 大话设计模式中的截图: 例子代码: 策略类: 1 package com.longsheng.strategy; 2 3 public abstract class Strategy { 4 5 public abstract double getR

&lt;二&gt;读&lt;&lt;大话设计模式&gt;&gt;之策略模式

又和大家见面了,能够坚持写出第二篇文章真不错,好好加油. <<大话设计模式>>讲解策略模式是以商场收银软件程序开头的,那么问题来了,哪家商场收银软件强,开玩笑了.读过上篇文章<<简单工厂模式>>的知道,它有两个缺点:1.客户端依赖两个类,耦合性高:2.如果算法过多则需要写很多类.解决上面问题的就是策略模式了. 策略模式:它定义了算法家族,分别封装起来,让它们之间可以互相替换,此模式让算法的变化,不会影响到使用算法的客户. 商场收银软件:单价*打折算法=售价.

【大话设计模式】——策略模式

一.开篇 上篇文章[大话设计模式]--简单工厂模式告诉了我们一个网吧收费工厂对象怎样创建收费形式(白天收费.夜间收费)的实例.简单工厂代码中有非常多 case分支语句 ,假设我们还想填加收费的形式(比方会员收费啊,通宵收费啊),就须要修改工厂代码,每次维护和扩展都要花费非常多时间,另外修改非常easy造成纰漏(比方之前的白天收费形式,非常可能由于修改从多收钱或者少收钱),所以简单工厂模式非常不安全.所以我们要把常常变化的代码抽象出来,做到业务逻辑和界面逻辑分开,仅仅有这样才干更加easy做到维护

大话设计模式之策略模式读后感

策略模式:定义了算法家族,分别封装起来,让他们呢之间可以互相的替换,此模式让算法的变化不会影响到使用算法的客户. UML类图: 解读:策略模式是定义一系列的算法,从概念上来讲,这些算法完成的工作都是一样的,只是他们的实现的不同,可以以相同的方式调用所有的算法,减少了各种算法类和算法调用类之间的耦合. 策略模式中的supperStrategy为context类提供了一系列的可供重用的算法或者行为.继承有助于提取出这些算法的公共功能. 在基本的策略模式中,选择所用具体实现的职责由客户端对象承担,并转

设计模式之策略模式【4】

一.模式定义 它定义了算法家族,分别封装起来,让它们之间可以相互替换,此模式让算法变化,不会影响到使用算法的客户. 二.模式分析 1.策略模式是一种定义一系列算法的方法,从概念上来看,所有这些算法完成的都是相同的工作,只是实现不同,它们可以以相同的方式调用所有算法,减少了各种算法类与是哟算法类之间的耦合. 2.策略模式的Strategy类层次为Context定义了一系列的可供重用的算法或者行为.继承有助于析取出这些算法中的公共功能. 3.策略模式就是用来封装算法的,但在实践中,我们发现可以用它来

学习大话设计模式02_工厂模式 进阶至 策略模式

1 /** 2 * 现金收费抽象类 3 * @author Monica 4 * 5 */ 6 public abstract class CashSuper { 7 /** 8 * 现金收取超类的抽象方法 9 * @param money 收取现金,参数为原价 10 * @return 返回当前价 11 */ 12 public abstract double acceptCash(double money); 13 } 14 15 /** 16 * 正常收费子类 17 * @author M

设计模式之策略模式(Strategy)摘录

23种GOF设计模式一般分为三大类:创建型模式.结构型模式.行为模式. 创建型模式抽象了实例化过程,它们帮助一个系统独立于如何创建.组合和表示它的那些对象.一个类创建型模式使用继承改变被实例化的类,而一个对象创建型模式将实例化委托给另一个对象.创建型模式有两个不断出现的主旋律.第一,它们都将关于该系统使用哪些具体的类的信息封装起来.第二,它们隐藏了这些类的实例是如何被创建和放在一起的.整个系统关于这些对象所知道的是由抽象类所定义的接口.因此,创建型模式在什么被创建,谁创建它,它是怎样被创建的,以

【大话设计模式】——代理模式

对于面向对象的程序设计语言而言,继承和多态是两个最基本的概念.Hibernate 的继承映射可以理解持久化类之间的继承关系.例如:人和学生之间的关系.学生继承了人,可以认为学生是一个特殊的人,如果对人进行查询,学生的实例也将被得到. Hibernate支持三种继承映射策略: 使用 subclass 进行映射:将域模型中的每一个实体对象映射到一个独立的表中,也就是说不用在关系数据模型中考虑域模型中的继承关系和多态. 使用 joined-subclass 进行映射: 对于继承关系中的子类使用同一个表

JavaScript设计模式之策略模式(学习笔记)

在网上搜索“为什么MVC不是一种设计模式呢?”其中有解答:MVC其实是三个经典设计模式的演变:观察者模式(Observer).策略模式(Strategy).组合模式(Composite).所以我今天选择学习策略模式. 策略模式:定义了一系列家族算法,并对每一种算法单独封装起来,让算法之间可以相互替换,独立于使用算法的客户. 通常我并不会记得“牛顿第一定律”的具体内容,所以我也难保证我会对这个定义记得多久……用FE经常见到的东西来举个例子说明一下: $("div").animation(