设计模式之(一)策略模式

发表于 | 分类于
字数统计: 1.5k 字 | 阅读时长 ≈ 6 分钟

本文首发于 我的个人博客

什么是策略模式

类型：行为类模式

策略模式定义了算法族，分别封装起来，让它们之间可以互相替换，此模式让算法的变化独立于使用算法的客户。——《Head First 设计模式》

场景

假设我们有个需求是，小孩和大人，小孩吃蔬菜，大人吃肉，小孩每天跑步一小时，大人每天跑步2小时，那么这个简单的需求怎么实现呢？

继承来实现

首先，我们想到的是继承，定义一个Person类，里么有两个方法

1
2
- (void)eatSomeThing;
- (void)runEveryDay;

然后，定义ChildPerson 和 AdultPerson 都继承自Person。然后在各自的类中，分别实现，eatSomeThing 和 runEveryDay 的方法

这种方法是可以，但是，有个问题，就是代码重用性较差，例如，如果再来一个 老人，吃蔬菜，能跑2小时，那么实现起来的话，就是在定义一个类 OldPerson 继承Person ,也实现eatSomeThing 和 runEveryDay 的方法，但问题是，我们之前已经实现了，吃蔬菜的方法，所以没必要再写重复的代码。

这时候，就可以用到策略模式

策略模式来实现

run

  • 协议 Run.h
1
2
3
4
5
#import <Foundation/Foundation.h>

@protocol Run <NSObject>
-(void)runEveryDay;
@end
  • 定义类 RunOneHour 准守协议 <Run>
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
#import <Cocoa/Cocoa.h>
#import "Run.h"

@interface RunOneHour : NSObject<Run>
- (void)runEveryDay;
@end


#import "RunOneHour.h"

@implementation RunOneHour
- (void)runEveryDay{
    NSLog(@"我每天能跑一个小时");
}
@end
  • 定义类 RunTwoHours准守协议 <Run>
1
2
3
4
5
6
7
8
9
10
11
12
13
14
#import <Cocoa/Cocoa.h>
#import "Run.h"

@interface RunTwoHours : NSObject<Run>
-(void)runEveryDay;
@end

#import "RunTwoHours.h"

@implementation RunTwoHours
- (void)runEveryDay{
    NSLog(@"我每天能跑两个小时");
}
@end

eat

  • 协议 Eat
1
2
3
4
5
6
#import <Foundation/Foundation.h>

@protocol Eat <NSObject>

- (void)eatSomeThing;
@end
  • 定义类 EatMeat准守协议 <Eat>
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
#import <Foundation/Foundation.h>
#import "Eat.h"

@interface EatMeat : NSObject<Eat>
- (void)eatSomeThing;
@end


#import "EatMeat.h"

@implementation EatMeat
- (void)eatSomeThing{
    NSLog(@"我吃肉");
}
@end
  • 定义类 EatVegetables准守协议 <Eat>
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
#import <Foundation/Foundation.h>
#import "Eat.h"

@interface EatVegetables : NSObject<Eat>
- (void)eatSomeThing;
@end



#import "EatVegetables.h"

@implementation EatVegetables
- (void)eatSomeThing{
    NSLog(@"我吃蔬菜");
}
@end

person

Person有两个属性，实现了<Eat>协议的eat属性 和 实现了<Run>协议的run属性
两个方法，分别是，eatSomeThing 和runEveryDay

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
#import <Foundation/Foundation.h>
#import "Eat.h"
#import "Run.h"
@interface Person : NSObject

@property (nonatomic,strong) id<Eat> eat;
@property (nonatomic,strong) id<Run> run;
- (void)eatSomeThing;
- (void)runEveryDay;
@end



#import "Person.h"

@implementation Person
- (void)eatSomeThing{
    [self.eat eatSomeThing];
}
- (void)runEveryDay{
    [self.run runEveryDay];
}
@end
  • ChildPerson
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
#import "Person.h"
@interface ChildPerson : Person
@end


#import "ChildPerson.h"
#import "EatVegetables.h"
#import "RunOneHour.h"
@implementation ChildPerson

- (instancetype)init
{
    self = [super init];
    if (self) {
        self.eat = [[EatVegetables alloc] init];
        self.run = [[RunOneHour alloc] init];
        NSLog(@"我是小孩");
    }
    return self;
}
@end
  • AdultPerson
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
#import "Person.h"
@interface AdultPerson : Person
@end


#import "AdultPerson.h"
#import "EatMeat.h"
#import "RunTwoHours.h"

@implementation AdultPerson
- (instancetype)init
{
    self = [super init];
    if (self) {
        self.eat = [[EatMeat alloc] init];
        self.run = [[RunTwoHours alloc] init];
        NSLog(@"我是大人");
    }
    return self;
}
@end

使用

1
2
3
4
5
6
7
Person *child = [[ChildPerson alloc] init];
[child eatSomeThing];
[child runEveryDay];
        
Person *adult = [[AdultPerson alloc] init];
[adult eatSomeThing];
[adult runEveryDay];

输出

1
2
3
4
5
6
2019-07-08 08:10:41.159747+0800 iOS-策略模式[1402:13333] 我是小孩
2019-07-08 08:10:41.160257+0800 iOS-策略模式[1402:13333] 我吃蔬菜
2019-07-08 08:10:41.160300+0800 iOS-策略模式[1402:13333] 我每天能跑一个小时
2019-07-08 08:10:41.160343+0800 iOS-策略模式[1402:13333] 我是大人
2019-07-08 08:10:41.160379+0800 iOS-策略模式[1402:13333] 我吃肉
2019-07-08 08:10:41.160396+0800 iOS-策略模式[1402:13333] 我每天能跑两个小时

这样就用策略模式实现了这个需求，如果这时候，增加一个需求 如果再来一个 老人，吃蔬菜，能跑2小时

只需要再定义一个类 OldPerson 如下

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
#import "Person.h"
@interface OldPerson : Person
@end

#import "OldPerson.h"
#import "RunTwoHours.h"
#import "EatVegetables.h"
@implementation OldPerson
- (instancetype)init
{
    self = [super init];
    if (self) {
        self.eat = [[EatVegetables alloc] init];
        self.run = [[RunTwoHours alloc] init];
        NSLog(@"我是老人");
    }
    return self;
}
@end

调用时候 只需要如下

1
2
3
Person *old = [[OldPerson alloc] init];
[old eatSomeThing];
[old runEveryDay];

即可输出

1
2
3
2019-07-08 08:46:16.007758+0800 iOS-策略模式[2567:27396] 我是老人
2019-07-08 08:46:16.007770+0800 iOS-策略模式[2567:27396] 我吃蔬菜
2019-07-08 08:46:16.007780+0800 iOS-策略模式[2567:27396] 我每天能跑两个小时

根本不需要重写吃，和跑的方法。

总结

优点

  • 策略模式是一种定义一系列算法的方法，从概念上来看，所有这些算法完成的都是相同的工作，只是实现不同，它可以以相同的方式调用所有的算法，减少了各种算法类与使用算法类之间的耦合。
  • 提供了可以替换继承关系的办法
  • 策略模式的Stategy类层次为Context定义了一些列的可供重用的算法或行为。继承有助于析取出算法中的公共功能。
  • 策略模式的优点是简化了单元测试，因为每个算法都有自己的类，可以通过自己的接口单独测试。
  • 易于扩展，增加一个新的策略对策略模式来说非常容易，基本上可以在不改变原有代码的基础上进行扩展

缺点

  • 维护各个策略类会给开发带来额外开销，一般来说，策略类的数量超过6个，就比较麻烦
  • 必须对客户端（调用者）暴露所有的策略类，因为使用哪种策略是由客户端来决定的，因此，客户端应该知道有什么策略，并且了解各种策略之间的区别，否则，后果很严重。

改进

  • 策略模式是一种简单常用的模式，我们在进行开发的时候，会经常有意无意地使用它，一般来说，策略模式不会单独使用，跟模版方法模式、工厂模式等混合使用的情况比较多。

Demo地址