iOS面试题（二十九）设计模式
10.设计模式
- 六大设计原则（设计模式所遵从的六大设计原则）
- 责任链
- 桥接
- 适配器
- 单例
- 命令
六大设计原则（设计模式所遵从的六大设计原则）
设计原则
- 单一职责原则：通俗地讲就是一个类只做一件事
CALayer：动画和视图的显示。
UIView：只负责事件传递、事件响应。
- 开闭原则：对修改关闭，对扩展开放。
要考虑到后续的扩展性，而不是在原有的基础上来回修改
- 接口隔离原则：使用多个专门的协议来做接口隔离、而不是一个庞大臃肿的协议
UITableviewDelegate
UITableViewDataSource
- 依赖倒置原则 ：抽象不应该依赖于具体实现、具体实现可以依赖于抽象。
调用接口感觉不到内部是如何操作的
- 里氏替换原则：父类可以被子类无缝替换，且原有的功能不受任何影响
例如 KVO
- 迪米特法则
一个对象应当对其他对象尽可能少的了解，实现高聚合、低耦合
模块和模块之前就少了千丝万缕的联系
二、责任链模式
要使用责任链模式来实现这种问题。
某一个类，它有一个成员变量，其类型是这个类本身。就是责任链模式。
主要思想：对象引用了同一类型的另一个对象，形成一条链。链中的每个对象实现了相同的方法，处理对链中第一个对象发起的同一请求，如果一个对象不知道如何处理，就把请求传给下一个响应器。
//BusinessObject.h
#import
@class BusinessObject;
typedef void(^CompletionBlock)(BOOL handled);
typedef void(^ResultBlock)(BusinessObject *handler, BOOL handled);
@interface BusinessObject : NSObject
// 下一个响应者(响应链构成的关键)
@property (nonatomic, strong) BusinessObject *nextBusiness;
// 响应者的处理方法
- (void)handle:(ResultBlock)result;
// 各个业务在该方法当中做实际业务处理
- (void)handleBusiness:(CompletionBlock)completion;
@end
// BusinessObject.m
@implementation BusinessObject
// 责任链入口方法
- (void)handle:(ResultBlock)result
{
CompletionBlock completion = ^(BOOL handled){
// 当前业务处理掉了，上抛结果
if (handled) {
result(self, handled);
}
else{
// 沿着责任链，指派给下一个业务处理
if (self.nextBusiness) {
[self.nextBusiness handle:result];
}
else{
// 没有业务处理, 上抛
result(nil, NO);
}
}
};
// 当前业务进行处理
[self handleBusiness:completion];
}
- (void)handleBusiness:(CompletionBlock)completion
{
/*
业务逻辑处理
如网络请求、本地照片查询等
*/
}
@end 桥接模式
列表和多套数据之间耦合的问题。
桥接模式的目的是把抽象层次结构从其实现中分离出来，使其能够独立变更。
类构成：
Class A 和ClassB都是抽象类。抽象类ClassA中一个成员变量是抽象类ClassB。
A1、A2、A3三个是ClassA的子类，B1、B2、B3是ClassB的三个子类。
ClassB中作为抽象类，只提供了默认的接口，并没有实现。B1、B2、B3是ClassB的三个子类，重写父类的接口方法，提供不同的实现，此时对于ClassB使用方来说，是感知到不使用了哪个实现。
ClassA中有一个handle处理方法，默认调用成员变量ClassB对象中的接口方法。A1、A2、A3三个是ClassA的子类，对于子类来说可以覆写父类的handle方法，做一些自定义的操作。
代码示例： ClassA
#import
#import "BaseObjectB.h"
@interface BaseObjectA : NSObject
// 桥接模式的核心实现
@property (nonatomic, strong) BaseObjectB *objB;
// 获取数据
- (void)handle;
@end
#import "BaseObjectA.h"
@implementation BaseObjectA
/*
组合方式：
A1 --> B1、B2、B3 3种
A2 --> B1、B2、B3 3种
A3 --> B1、B2、B3 3种
*/
- (void)handle
{
// override to subclass
// 处理objB中的方法。
[self.objB fetchData];
}
@end
ClassA的子类A1、A2、A3重写父类中handle方法。
#import "ObjectA1.h"
@implementation ObjectA1
- (void)handle
{
// before 业务逻辑操作
[super handle];
// after 业务逻辑操作
}
@end
ClassB 实现
#import
@interface BaseObjectB : NSObject
- (void)fetchData;
@end
#import "BaseObjectB.h"
@implementation BaseObjectB
// 默认逻辑实现
- (void)fetchData
{
// override to subclass
}
@end
ClassB的子类进行具体的逻辑实现。
#import "ObjectB1.h"
@implementation ObjectB1
- (void)fetchData{
// 具体的逻辑处理
}
@end
使用方代码实现
@interface BridgeDemo()
@property (nonatomic, strong) BaseObjectA *objA;
@end
@implementation BridgeDemo
/*
根据实际业务判断使用那套具体数据
A1 --> B1、B2、B3 3种
A2 --> B1、B2、B3 3种
A3 --> B1、B2、B3 3种
*/
- (void)fetch
{
// 创建一个具体的ClassA
_objA = [[ObjectA1 alloc] init];
// 创建一个具体的ClassB
BaseObjectB *b1 = [[ObjectB1 alloc] init];
// 将一个具体的ClassB1 指定给抽象的ClassB
_objA.objB = b1;
// 获取数据
[_objA handle];
}
@end
使用方中定义了ClassA对象，可以使用A1、A2、A3来创建不同的对象，获取不同的实现组合。BaseObjectB也可以有不同的实现组合。通过桥接模式不同的组合可以实现对象之间的解耦。
桥接模式的优点：
-
分离抽象接口及其实现部分。
-
桥接模式有时类似于多继承方案，但是多继承方案违背了类的单一职责原则（即一个类只有一个变化的原因），复用性比较差，而且多继承结构中类的个数非常庞大，桥接模式是比多继承方案更好的解决方法。
-
桥接模式提高了系统的可扩充性，在两个变化维度中任意扩展一个维度，都不需要修改原有系统。
-
实现细节对客户透明，可以对用户隐藏实现细节。
四、适配器
适配器模式(Adapter Pattern)：将一个接口转换成客户希望的另一个接口，适配器模式使接口不兼容的那些类可以一起工作，其别名为包装器(Wrapper)。适配器模式既可以作为类结构型模式，也可以作为对象结构型模式。
本节主要学习对象适配器模式，简单的类结构如下。
适配对象中一个成员变量指向被适配对象。
示例代码：类Target是被适配对象，CoolTarget为适配对象。
Target类
#import
@interface Target : NSObject
- (void)operation;
@end
#import "Target.h"
@implementation Target
- (void)operation
{
// 原有的具体业务逻辑
}
@end
CoolTarget类：
#import "Target.h"
// 适配对象
@interface CoolTarget : NSObject
// 被适配对象
@property (nonatomic, strong) Target *target;
// 对原有方法包装
- (void)request;
@end
#import "CoolTarget.h"
@implementation CoolTarget
- (void)request
{
// 额外处理
[self.target operation];
// 额外处理
}
@end
适配器优点：
-
将目标类和适配者类解耦，通过引入一个适配器类来重用现有的适配者类，而无须修改原有代码。
-
增加了类的透明性和复用性，将具体的实现封装在适配者类中，对于客户端类来说是透明的，而且提高了适配者的复用性。
-
灵活性和扩展性都非常好，通过使用配置文件，可以很方便地更换适配器，也可以在不修改原有代码的基础上增加新的适配器类，完全符合“开闭原则”。
三、单例
单例模式(SingletonPattern)：单例模式确保某一个类只有一个实例，而且自行实例化并向整个系统提供这个实例，这个类称为单例类，它提供全局访问的方法。
单例模式的要点有三个：一是某个类只能有一个实例；二是它必须自行创建这个实例；三是它必须自行向整个系统提供这个实例。单例模式是一种对象创建型模式。单例模式又名单件模式或单态模式。
示例代码：
@implementation Mooc
+ (id)sharedInstance
{
// 静态局部变量
static Mooc *instance = nil;
// 通过dispatch_once方式 确保instance在多线程环境下只被创建一次
static dispatch_once_t onceToken;
dispatch_once(&onceToken, ^{
// 创建实例
instance = [[super allocWithZone:NULL] init];
});
return instance;
}
// 重写方法【必不可少】
+ (id)allocWithZone:(struct _NSZone *)zone{
return [self sharedInstance];
}
// 重写方法【必不可少】
- (id)copyWithZone:(nullable NSZone *)zone{
return self;
}
@end
注意点：为了防止使用者创建对象，需要从重写两个方法allocWithZone和copyWithZone:。
另外instance = [[super allocWithZone:NULL] init];需要使用super方法调用防止在第一创建时循环调用。
四、命令模式
命令模式(CommandPattern)：行为参数化的一种模式
（比如微博里面各个页面都会涉及到转发评论赞，如果我们把转发评论赞分别进行封装，以行为参数化的形式封装起来，当用户点击按钮的时候，再进行触发，降低系统的重合度。）
代码实例：一个命令对象和一个命令管理者。
Command
@class Command;
typedef void(^CommandCompletionCallBack)(Command* cmd);
@interface Command : NSObject
@property (nonatomic, copy) CommandCompletionCallBack completion; // 执行回调
- (void)execute; // 执行
- (void)cancel; // 取消
- (void)done; // 完成
@end
#import "Command.h"
#import "CommandManager.h"
@implementation Command
- (void)execute{
//override to subclass;
[self done];
}
- (void)cancel{
self.completion = nil;
}
- (void)done
{
dispatch_async(dispatch_get_main_queue(), ^{
if (_completion) {
_completion(self);
}
//释放
self.completion = nil;
// 在数组中移除
[[CommandManager sharedInstance].arrayCommands removeObject:self];
});
}
@end
CommandManager
可以用CommandManager保证任务的顺序执行，使用一个正在执行任务数组和一个等待执行任务数组，可以参考SDWebImage图片下载思路
#import
#import "Command.h"
@interface CommandManager : NSObject
// 命令管理容器
@property (nonatomic, strong) NSMutableArray *arrayCommands;
// 命令管理者以单例方式呈现
+ (instancetype)sharedInstance;
// 执行命令
+ (void)executeCommand:(Command *)cmd completion:(CommandCompletionCallBack)completion;
// 取消命令
+ (void)cancelCommand:(Command *)cmd;
@end
#import "CommandManager.h"
@implementation CommandManager
// 命令管理者以单例方式呈现
+ (instancetype)sharedInstance
{
static CommandManager *instance = nil;
static dispatch_once_t onceToken;
dispatch_once(&onceToken, ^{
instance = [[super allocWithZone:NULL] init];
});
return instance;
}
// 【必不可少】
+ (id)allocWithZone:(struct _NSZone *)zone{
return [self sharedInstance];
}
// 【必不可少】
- (id)copyWithZone:(nullable NSZone *)zone{
return self;
}
// 初始化方法
- (id)init
{
self = [super init];
if (self) {
// 初始化命令容器
_arrayCommands = [NSMutableArray array];
}
return self;
}
+ (void)executeCommand:(Command *)cmd completion:(CommandCompletionCallBack)completion
{
if (cmd) {
// 如果命令正在执行不做处理，否则添加并执行命令
if (![self _isExecutingCommand:cmd]) {
// 添加到命令容器当中
[[[self sharedInstance] arrayCommands] addObject:cmd];
// 设置命令执行完成的回调
cmd.completion = completion;
//执行命令
[cmd execute];
}
}
}
// 取消命令
+ (void)cancelCommand:(Command *)cmd
{
if (cmd) {
// 从命令容器当中移除
[[[self sharedInstance] arrayCommands] removeObject:cmd];
// 取消命令执行
[cmd cancel];
}
}
// 判断当前命令是否正在执行
+ (BOOL)_isExecutingCommand:(Command *)cmd
{
if (cmd) {
NSArray *cmds = [[self sharedInstance] arrayCommands];
for (Command *aCmd in cmds) {
// 当前命令正在执行
if (cmd == aCmd) {
return YES;
}
}
}
return NO;
}
@end
命令模式的优点
-
降低系统的重合度。
-
新的命令可以很容易地加入到系统中。
-
可以比较容易地设计一个命令队列和宏命令（组合命令）。
-
可以方便地实现对请求的Undo和Redo。
怎么创建一个单例：
- 通过dispatch_once方式 确保instance在多线程环境下只被创建一次的对象。
- 为了防止使用者创建对象，需要从重写两个方法
allocWithZone和copyWithZone:。 - 另外
instance = [[super allocWithZone:NULL] init];需要使用super方法调用防止在第一创建时循环调用。
你知道什么设计原则？
桥接模式主体结构：
定义一个抽象父类Class A 和抽象父类ClassB。把抽象类ClassB作为抽象类ClassA中一个成员变量。
A1、A2、A3三个是ClassA的子类，B1、B2、B3是ClassB的三个子类。
然后就可以衍生出A1-B1 A1-B3 这样的关系。
两个父类其中持有一个，就构成了桥梁作用。
UI事件传递机制是怎样实现的？你对其中运用到的设计模式是怎样理解的？
设计模式角度是是责任链模式，一个类，它有一个成员变量，其类型是当前类的类型，就构成了责任链模式的基本结构。