什么是策略模式
策略模式定义了算法族，分别封装起来，让它们之间可以互相替换，此模式让算法的变化独立于使用算法的客户。——《Head First 设计模式》
这里引用了《Head First 设计模式》里的定义。其中算法族是指一系列算法，可以把算法理解为对象的行为（方法）。
这里用到了一个设计原则：
找出应用中可能需要变化之处，把它们独立出来，不要和那些不需要变化的代码混在一起。
这是一个让我耳目一新的思想，我的固有思维里总是把不变的东西封装起来，比如基类的使用（当然，这些变化里其实是有不变的——相同方法的不同实现）。而这种思想是“把会变化的部分取出来并封装起来，以便以后可以轻易地改动或扩充此部分，而不影响不需要变化的其它部分”。在接下来的实践中我们会更加深刻地体会这种思想。
需求场景
现有一个野鸭类MallardDuck，野鸭会飞 fly()，会叫 quack()。很快有了新的需求，我们要实现一个家鸭（饲养的鸭子）的类DomesticDuck，家鸭不会飞fly()，叫声quack()（嘎嘎叫）也和野鸭MallardDuck（咕咕叫）不同。
通常情况下利用面向对象的思想，根据鸭子的共性我们会抽出一个鸭子基类Duck。然后继承创建野鸭类MallardDuck和家鸭类DomesticDuck，并在子类里分别重写飞的方法fly()和叫的方法quack()。
但是，这样实现方式有一个问题，我们知道需求总是在不断变化的，产品经理某一天突发奇想要很多其它类别的鸭子，并且鸭子的飞行的方式fly()和叫的方式quack()可能一样，也可能不一样。如果我们总是在子类里重写方法，就没办法对相同的方法进行重用，而且也不能方便地对每个类的方法进行修改。
所以，我们应该把鸭子的行为从鸭子类Duck里剥离出来单独封装。
解决方案
这里有两种解决方案。
实现继承
方案一：将行为封装为类，通过继承在子类重写行为方法，我们将之称为实现继承。
具体实现：创建FlyBehavior类和QuackBehavior类，分别在类中实现fly()和quack()，然后继承创建子类FlyWithWings和FlyNoWay。对QuackBehavior做同样的处理，GuGuQuack和GaGaQuack。
%u56FE1
%u56FE2
这样似乎也能解决问题，但是我们根据针对接口编程，而不是针对实现编程的设计原则采用第二种解决方案。“针对接口编程”的意思是“针对超类型编程”，即“变量的声明类型应该是超类型，通常是一个抽象类或者是一个接口”。利用多态机制，只要是实现了该接口的对象都可以指定给这个变量，运行时根据实际赋予的变量执行真正的行为。实现和接口分离，而不是死绑在一起。
接口继承
方案二：把行为设计成接口，再让具体的行为类去实现对应的方法。
具体实现：在 Objective-C 中，我们可以用协议Protocal来定义飞行为<FlyBehavior>和叫行为<QuackBehavior>，让具体的行为类（FlyWithWings<FlyBehavior>、FlyNoWay<FlyBehavior>、GuGuQuack<QuackBehavior>、GaGaQuack<QuackBehavior>）去实现相应的方法。
代码实现
下面给出方案二的代码实现。
Duck 类
Duck.h 文件
import <Foundation/Foundation.h>
import "FlyBehavior.h"
import "QuackBehavior.h"
@interface Duck : NSObject
@property (strong, nonatomic)id<FlyBehavior> flyBehavior;
@property (strong, nonatomic)id<QuackBehavior> quackBehavior;
- (void)performFly;
- (void)performQuack;
@end
Duck.m 文件
import "Duck.h"
@implementation Duck
(void)performFly{
[self.flyBehavior fly];
}(void)performQuack{
[self.quackBehavior quack];
}
@end
MallardDuck 类
MallardDuck.h 文件
import "Duck.h"
@interface MallardDuck : Duck
@end
MallardDuck.m 文件
import "MallardDuck.h"
import "FlyWithWings.h"
import "GuGuQuack.h"
@implementation MallardDuck
- (instancetype)init{
if (self = [super init]) {
self.flyBehavior = [[FlyWithWings alloc]init];
self.quackBehavior = [[GuGuQuack alloc]init];
NSLog(@"I'm a mallardDuck");
}
return self;
}
@end
DomesticDuck 类
DomesticDuck.h 文件
import "Duck.h"
@interface DomesticDuck : Duck
@end
DomesticDuck.m 文件
import "DomesticDuck.h"
import "FlyNoWay.h"
import "GaGaQuack.h"
@implementation DomesticDuck
- (instancetype)init{
if (self = [super init]) {
self.quackBehavior = [[GaGaQuack alloc]init];
self.flyBehavior = [[FlyNoWay alloc]init];
NSLog(@"I'm a DomesticDuck");
}
return self;
}
@end
FlyBehavior 协议
FlyBehavior.h 文件
import <Foundation/Foundation.h>
@protocol FlyBehavior <NSObject>
@required
- (void)fly;
@end
FlyNoWay 类
FlyNoWay.h 文件
import <Foundation/Foundation.h>
import "FlyBehavior.h"
@interface FlyNoWay : NSObject <FlyBehavior>
- (void)fly;
@end
FlyNoWay.m 文件
import "FlyNoWay.h"
@implementation FlyNoWay
- (void)fly{
NSLog(@"I can't fly");
}
@end
FlyWithWings 类
FlyWithWings.h 文件
import <Foundation/Foundation.h>
import "FlyBehavior.h"
@interface FlyWithWings : NSObject <FlyBehavior>
- (void)fly;
@end
FlyWithWings.m 文件
import "FlyWithWings.h"
@implementation FlyWithWings
- (void)fly{
NSLog(@"I can fly");
}
@end
整合调用
main.m 文件
import <Foundation/Foundation.h>
import "MallardDuck.h"
import "DomesticDuck.h"
int main(int argc, const char * argv[]) {
@autoreleasepool {
// insert code here...
Duck *mallardDuck = [[MallardDuck alloc]init];
[mallardDuck performFly];
[mallardDuck performQuack];
Duck *domesticDuck = [[DomesticDuck alloc]init];
[domesticDuck performFly];
[domesticDuck performQuack];
}
return 0;
}
