什么是策略模式

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

这里引用了《Head First 设计模式》里的定义。其中算法族是指一系列算法，可以把算法理解为对象的行为（方法）。

这里用到了一个设计原则：

找出应用中可能需要变化之处，把它们独立出来，不要和那些不需要变化的代码混在一起。

这是一个让我耳目一新的思想，我的固有思维里总是把不变的东西封装起来，比如基类的使用（当然，这些变化里其实是有不变的——相同方法的不同实现）。而这种思想是“把会变化的部分取出来并封装起来，以便以后可以轻易地改动或扩充此部分，而不影响不需要变化的其它部分”。在接下来的实践中我们会更加深刻地体会这种思想。

需求场景

现有一个野鸭类MallardDuck，野鸭会飞 fly()，会叫 quack()。很快有了新的需求，我们要实现一个家鸭（饲养的鸭子）的类DomesticDuck，家鸭不会飞fly()，叫声quack()（嘎嘎叫）也和野鸭MallardDuck（咕咕叫）不同。

通常情况下利用面向对象的思想，根据鸭子的共性我们会抽出一个鸭子基类Duck。然后继承创建野鸭类MallardDuck和家鸭类DomesticDuck，并在子类里分别重写飞的方法fly()和叫的方法quack()。

所以，我们应该把鸭子的行为从鸭子类Duck里剥离出来单独封装。

解决方案

这里有两种解决方案。

实现继承

• 方案一：将行为封装为类，通过继承在子类重写行为方法，我们将之称为实现继承。
• 具体实现：创建FlyBehavior类和QuackBehavior类，分别在类中实现fly()和quack()，然后继承创建子类FlyWithWings和FlyNoWay。对QuackBehavior做同样的处理，GuGuQuack和GaGaQuack。
  
  
  
  
  
  
  这样似乎也能解决问题，但是我们根据针对接口编程，而不是针对实现编程的设计原则采用第二种解决方案。“针对接口编程”的意思是“针对超类型编程”，即“变量的声明类型应该是超类型，通常是一个抽象类或者是一个接口”。利用多态机制，只要是实现了该接口的对象都可以指定给这个变量，运行时根据实际赋予的变量执行真正的行为。实现和接口分离，而不是死绑在一起。

接口继承

• 方案二：把行为设计成接口，再让具体的行为类去实现对应的方法。
• 具体实现：在 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;
}

源代码地址

Github地址: https://github.com/Zentopia/DesignPatterns

参考资料

• 《Head First 设计模式(Java)》