策略模式：定义算法簇，并独立出来，让他们可以相互替换。
策略模式是众多的行为性模式之一。
策略模式
往往在处理某些问题的时候我们会用if-else ，如果条件很多，那么if-else if-else会无穷无尽。这本身就不便于维护。并且每次增加一种条件，那么就需要修改代码，这种方式违背了开闭原则（扩展是开放的，修改是闭合的）。
所以在处理问题时某些行为（功能）是可选的/互斥的，那么可以考虑使用策略模式。
举个栗子
我家有一只狗，它能吃东西，也能叫，好狗！
这个时候忽然有天啸天犬出现了？啸天犬会飞啊。它是神犬。
某天去游泳，带着旺财,来福和富贵。旺财会游泳游的还行，来福刚下水就沉向了水底，咕噜噜冒泡，富贵在水里就跟飞鱼一样，游的很欢。
这里我们说到了两种行为。一种是会飞的行为，一种是游泳的行为。
如果我们单纯的给狗的基类定义吃，叫的行为，然后其他的通过根据具体类来实现，确实可以。那将来会有更多的变化呢？啸天犬，神犬七公，天狗再加上几十个品种的凡犬，然后到每个类中再去修改？如果有100个类，然后每个类都各有不同，那就是噩梦。
这个时候我们不妨定义多个算法，会飞的算法，游泳的算法，我们都给狗加上去这些行为在他们要展示行为的时候就调用算法。这样每次有一只新狗，那就直接根据它的能力替换算法就完事了。
直接上狗
#import <Foundation/Foundation.h>
#import "Fly.h"
#import "Swim.h"
NS_ASSUME_NONNULL_BEGIN
@interface Dog : NSObject
@property(nonatomic,strong)id<Fly> flyer;
@property(nonatomic,strong)id<Swim> swimmer;
-(void)bark;
-(void)eat;
-(NSString *)performToSwim;
-(NSString *)performFly;
@end
NS_ASSUME_NONNULL_END
狗基类的实现
#import "Dog.h"
#import "NoFlyBehavior.h"
#import "NoSwimming.h"
@implementation Dog
-(instancetype)init {
if (self = [super init]) {
_swimmer = [[NoSwimming alloc] init];
_flyer = [[NoFlyBehavior alloc] init];
}return self;
}
-(NSString *)performToSwim {
return [self.swimmer swim];
}
-(NSString *)performFly {
return [self.flyer fly];
}
-(void)bark {
}
-(void)eat {
}
@end
Fly协议
#import <Foundation/Foundation.h>
NS_ASSUME_NONNULL_BEGIN
@protocol Fly <NSObject>
-(NSString *)fly;
@end
NS_ASSUME_NONNULL_END
swim协议
#import <Foundation/Foundation.h>
NS_ASSUME_NONNULL_BEGIN
@protocol Swim <NSObject>
-(NSString *)swim;
@end
NS_ASSUME_NONNULL_END
快速飞行的算法
#import "QuickFlyBehavior.h"
@implementation QuickFlyBehavior
-(NSString *)fly {
return @"快速的飞过去了！";
}
@end
普通飞行的算法
#import "NomalFlyBehavior.h"
@implementation NomalFlyBehavior
-(NSString *)fly {
return @"飞过去了！";
}
@end
不会飞行的算法
#import "NoFlyBehavior.h"
@implementation NoFlyBehavior
-(NSString *)fly {
return @"没长翅膀怎么飞？";
}
@end
游泳的算法
#import "Swimming.h"
@implementation Swimming
-(NSString *)swim {
return @"愉快的游泳！";
}
@end
不会游泳的算法
#import "NoSwimming.h"
@implementation NoSwimming
-(NSString *)swim {
return @"救命，不会游泳，快淹死了！";
}
@end
实际调用
#import <Foundation/Foundation.h>
#import "ChinieseDog.h"
#import "Swimming.h"
#import "NomalFlyBehavior.h"
#import "QuickFlyBehavior.h"
int main(int argc, const char * argv[]) {
@autoreleasepool {
ChinieseDog * dog = [[ChinieseDog alloc] init];
[dog performToSwim];
dog.swimmer = [[Swimming alloc] init];;
[dog performToSwim];
[dog performFly];
dog.flyer = [[QuickFlyBehavior alloc] init];
[dog performFly];
}
return 0;
}
优点
1.算法之间可以自由切换
2.使用策略模式能避免多重条件判断
3.增加了扩展性
缺点
1.策略类过多
2.所有策略类都需要向外暴露
