策略模式（Strategy Pattern）

策略模式：定义算法簇，并独立出来，让他们可以相互替换。

策略模式是众多的行为性模式之一。

策略模式

往往在处理某些问题的时候我们会用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.所有策略类都需要向外暴露