六大设计原则
单一职责
一个类则负责一件事。UIView只负责事件传递和响应。CALayer 视图展示
开闭原则
对修改关闭，对扩展开放
接口隔离
使用多个专门的协议，而不是一个庞大臃肿的协议。协议中的方法应尽量的少。eg. UITableViewDataSource 、UITableViewDelegate
依赖倒置原则
抽象不应该依赖于具体的实现，具体实现可以依赖抽象。eg. 上层只知道增删改查，不用知道底层用的是那种数据存储方案
里氏替换原则
父类可以被子类无缝替换，且原有功能不受影响 eg.KVO
迪米特法则
一个对象应当对其他对象有尽可能的少的了解。 高内聚、低耦合
五大设计模式
责任链
概念：为请求创建了一个对象响应者链。关键是：响应链。
场景：业务处理顺序A --> B --> C 变更为 C --> B --> A
代码实现
@class Business;
typedef void (^CompletionBlock)(BOOL handled);
typedef void (^ResultBlock)(Business *handler,BOOL handled);
@interface Business : NSObject
@property(nonatomic,strong)Business *nextBusiness;
@property(nonatomic,assign)int tag;
-(void)handle:(ResultBlock)result;
@end
@implementation Business
-(void)handle:(ResultBlock)result
{
[self handleBusiness:^(BOOL handled) {
if(handled){
result(self,handled);
}else{
if(self.nextBusiness){
[self.nextBusiness handle:result];
}else{
result(nil,NO);
}
}
}];
}
-(void)handleBusiness:(CompletionBlock)completion
{
if(_tag == 3){
NSLog(@"tag = %d 处理",_tag);
completion(YES);
}else{
NSLog(@"tag = %d 不处理",_tag);
completion(NO);
}
}
@end
- (void)viewDidLoad {
[super viewDidLoad];
Business *a = [[Business alloc]init];
a.tag = 4;
Business *b = [[Business alloc]init];
b.tag = 5;
Business *c = [[Business alloc]init];
c.tag = 3;
Business *d = [[Business alloc]init];
d.tag = 1;
a.nextBusiness = b;
b.nextBusiness = c;
c.nextBusiness = d;
[a handle:^(Business *handler, BOOL handled) {
}];
}
2018-04-23 14:52:56.793052+0800 TestDemo[2965:170447] tag = 4 不处理
2018-04-23 14:52:56.793195+0800 TestDemo[2965:170447] tag = 5 不处理
2018-04-23 14:52:56.793326+0800 TestDemo[2965:170447] tag = 3 处理
桥接模式
概念：抽象化与实现化解耦，使得二者可以独立变化
场景：列表根据三种不同数据源，显示三种不同的样式
解除列表和数据的耦合: ClassA带表列表抽象，ClassB代表数据数据抽象。ClassA拥有一个ClassB的实例对象。A1 B1等是具体实现。
代码实现
@interface BaseView : UIView
//桥接模式核心实现
@property(nonatomic,strong)BaseData *data;
//获取数据
-(void)handle;
@end
@implementation BaseView
-(void)handle
{
[self.data fetchData];
}
@end
@interface BaseData : NSObject
-(void)fetchData;
@end
@implementation BaseData
-(void)fetchData
{
//ovveride to subClass
}
@end
//在ViewDidLoad中，可以随意组合列表和数据
BaseView *view = [[View1 alloc]init];
view.data = [[Data2 alloc]init];
[view handle];
适配器
概念：
对象适配器： 新的类包含一个旧的类的实例对象， 引入新的逻辑。将一个类的接口转换成客户希望的另外一个接口
类适配器：继承，通过子类引入新的逻辑
场景：旧的类使用好几年了没有变动。但是需求边了。要加入一些新的东西
@interface Target : NSObject
-(void)operation;
@end
@interface CoolTarget : NSObject
@property(nonatomic,strong)Target *target; //被适配对象
-(void)request;
@end
@implementation CoolTarget
-(void)request
{
//额外处理
[self.target operation];
//额外处理
}
@end
单例模式
概念：该类负责创建自己的对象，同时确保只有单个对象被创建
+(instancetype)sharedInstance
{
static User *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)copy
{
return self;
}
命令模式
概念：行为参数化，降低代码重合度。
场景：将一个请求封装成一个对象，并把命令传给响应的对象。eg .点赞，转发等这些常见需求
代码实现
@class Command;
typedef void (^CommandCompletionCallBack)(Command* cmd);
@interface Command : NSObject
@property(nonatomic,copy)CommandCompletionCallBack completion;
-(void)execute;
-(void)cancel;
-(void)done;
@end
@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;
});
}
@end
@interface CommandManager : NSObject
@property(nonatomic,strong)NSMutableArray<Command*> *arrayCommands;
+(instancetype)sharedInstance;
//执行命令
+(void)executeCommand:(Command *)cmd completion:(CommandCompletionCallBack)completion;
//取消命令
+(void)cancelCommand:(Command *)cmd;
@end
@implementation CommandManager
+(instancetype)sharedInstance
{
static CommandManager *instance = nil;
static dispatch_once_t onceToken;
dispatch_once(&onceToken, ^{
instance = [[super allocWithZone:NULL]init];
});
return instance;
}
-(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]){
[[[CommandManager sharedInstance] arrayCommands] addObject:cmd];
cmd.completion = completion;
[cmd execute];
}
}
}
//取消命令
+(void)cancelCommand:(Command *)cmd
{
if(cmd){
[[[CommandManager sharedInstance] arrayCommands] removeObject:cmd];
[cmd cancel];
}
}
+(BOOL)_isExecutingCommand:(Command*)cmd
{
NSArray *cmds = [[CommandManager sharedInstance] arrayCommands];
for (Command *aCmd in cmds) {
if(cmd == aCmd){
return YES;
}
}
return NO;
}
@end
