iOS 设计模式系列一:策略模式

来源:转载


什么是策略模式

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


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


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


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


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


需求场景

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


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




但是,这样实现方式有一个问题,我们知道需求总是在不断变化的,产品经理某一天突发奇想要很多其它类别的鸭子,并且鸭子的飞行的方式fly()和叫的方式quack()可能一样,也可能不一样。如果我们总是在子类里重写方法,就没办法对相同的方法进行重用,而且也不能方便地对每个类的方法进行修改。


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


解决方案

这里有两种解决方案。


实现继承
方案一:将行为封装为类,通过继承在子类重写行为方法,我们将之称为实现继承。
具体实现:创建FlyBehavior类和QuackBehavior类,分别在类中实现fly()quack(),然后继承创建子类FlyWithWingsFlyNoWay。对QuackBehavior做同样的处理,GuGuQuackGaGaQuack





这样似乎也能解决问题,但是我们根据针对接口编程,而不是针对实现编程的设计原则采用第二种解决方案。“针对接口编程”的意思是“针对超类型编程”,即“变量的声明类型应该是超类型,通常是一个抽象类或者是一个接口”。利用多态机制,只要是实现了该接口的对象都可以指定给这个变量,运行时根据实际赋予的变量执行真正的行为。实现和接口分离,而不是死绑在一起。
接口继承
方案二:把行为设计成接口,再让具体的行为类去实现对应的方法。
具体实现:在 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)》



分享给朋友:
您可能感兴趣的文章:
随机阅读: