Objective-C-----协议protocol，代码块block，分类category

概述

ObjC的语法主要基于smalltalk进行设计的，除了提供常规的面向对象特性外，还增加了很多其他特性，本文将重点介绍objective-C中一些常用的语法特性。

当然这些内容虽然和其他高级语言命名不一样，但是我们都可以在其中找到他们的影子，在文章中我也会对比其他语言进行介绍，本文的重点内容如下：

1. 协议protocol
2. 代码块block
3. 分类category

协议protocol

 

在Objective-C中使用@protocol定义一组方法规范，实现此协议的类必须实现对应的方法。熟悉面向对象的童鞋都知道接口本身是对象行为描述的协议规范。

也就是说在Objective-C中@protocol和其他语言的接口定义是类似的，只是在Objective-C中interface关键字已经用于定义类了，

因此它不会再像C#、Java中使用interface定义接口了。

假设我们定义了一个动物的协议AnimalDelegate，人员Person这个类需要实现这个协议，请看下面的代码：

 

AnimalDelegate.h


//定义一个协议  
@protocol AnimalDelegate <NSObject>  
  
@required //必须实现的方法  
-(void)eat;  
  
@optional //可选实现的方法  
-(void)run;  
-(void)say;  
-(void)sleep;  
  
@end  
   
Person.h
  
#import<Foundation/Foundation.h>  
#import "AnimalDelegate.h"  
  
@interface Person : NSObject<AnimalDelegate>  
  
-(void)eat;  
  
@end  
  

Person.m
#import"Person.h"  
  
@implementation Person  
  
-(void)eat{  
    NSLog(@"eating...");  
}  
  
@end

 

 

 

说明几点：

• 一个协议可以扩展自另一个协议，例如上面AnimalDelegate就扩展自NSObject，如果需要扩展多个协议中间使用逗号分隔；
• 和其他高级语言中接口不同的是协议中定义的方法不一定是必须实现的，我们可以通过关键字进行@required和@optional进行设置，如果不设置则默认是@required（注意Objective-C是弱语法，即使不实现必选方法编译运行也不会报错）；
• 协议通过<>进行实现，一个类可以同时实现多个协议，中间通过逗号分隔；
• 协议的实现只能在类的声明上,不能放到类的实现上（也就是说必须写成@interfacePerson:NSObject<AnimalDelegate>而不能写成@implementation Person<AnimalDelegate>）；
• 协议中不能定义属性、成员变量等,只能定义方法；

事实上在Objective-C中协议的更多作用是用于约束一个类必须实现某些方法，而从面向对象的角度而言这个类跟接口并不一定存在某种自然关系，可能是两个完全不同意义上的事物,这种模式我们称之为代理模式（Delegation）。在Cocoa框架中大量采用这种模式实现数据和UI的分离，而且基本上所有的协议都是以Delegate结尾。

现在假设需要设计一个按钮，我们知道按钮都是需要点击的，在其他语言中通常会引入事件机制，只要使用者订阅了点击事件，那么点击的时候就会触发执行这个事件（这是对象之间解耦的一种方式：代码注入）。但是在ObjC中没有事件的定义，而是使用代理来处理这个问题。首先在按钮中定义按钮的代理，同时使用协议约束这个代理（事件的触发者）必须实现协议中的某些方法，当按钮处理过程中查看代理是否实现了这个方法，如果实现了则调用这个方法。

 

LCButton.h

#import <Foundation/Foundation.h>  
@classLCButton  
//一个协议可以扩展另一个协议，例如LCButtonDelegate扩展了NSObject协议  
@protocol LCButton<NSObject>  
@required //@required修饰的方法必须实现  
-(void)onClick:(LCButton *)button;  
@optional //@optional修饰的方法是可选实现的  
-(void)onMouseover:(LCButton *)button;  
-(void)onMouseout:(LCButton *)button;  
@end  
@interface LCButton : NSObject  
#pragma mark - 属性  
#pragma mark 代理属性，同时约定作为代理的对象必须实现协议  
@property (nonatomic,retain) id<LCButtonDelegate> delegate;  
#pragma mark - 公共方法  
#pragma mark 点击方法  
-(void)click;  
  
@end  


LCButton.m
 
#import LCButton  
@implementation KCButton  
  
-(void)click{  
    NSLog(@"Invoke KCButton's click method.");  
    //判断_delegate实例是否实现了onClick:方法（注意方法名是"onClick:",后面有个:）  
    //避免未实现ButtonDelegate的类也作为KCButton的监听  
    if([_delegate respondsToSelector:@selector(onClick:)]){  
        [_delegate onClick:self];  
    }  
}  
  
@end  


LCListener.h
#import <Foundation/Foundation.h>  
@class LCButton;  
@protocol LCButtonDelegate;  
  
@interfaceLCListener : NSObject<LCButtonDelegate>  
-(void)onClick:(LCButton *)button;  
@end

LCListener.m  
#import "LCListener.h"  
#import "LCButton.h"  
  
@implementation LCListener  
-(void)onClick:(LCButton *)button{  
    NSLog(@"Invoke MyListener's onClick method.The button is:%@.",button);  
}  
@end

我们通过例子模拟了一个按钮的点击过程，有点类似于Java中事件的实现机制。通过这个例子我们需要注意以下几点内容：

1. id可以表示任何一个objective-C对象类型，类型后面的”<协议名>“用于约束作为这个属性的对象必须实现该协议(注意：使用id定义的对象类型不需要加“*”)；
2. LCListener作为事件触发者，它实现了LCButtonDelegate代理（在objective-C中没有命名空间和包的概念，通常通过前缀进行类的划分，“LC”是我们自定义的前缀）
3. 在.h文件中如果使用了另一个文件的类或协议我们可以通过@class或者@protocol进行声明，而不必导入这个文件，这样可以提高编译效率（注意有些情况必须使用@class或@protocol，例如上面LCButton.h中上面声明的LCButtonDelegate协议中用到了LCButton类，而此文件下方的LCButton类声明中又使用了LCButtonDelegate，从而形成在一个文件中互相引用关系，此时必须使用@class或者@protocol声明，否则编译阶段会报错），但是在.m文件中则必须导入对应的类声明文件或协议文件（如果不导入虽然语法检查可以通过但是编译链接会报错）；
4. 使用respondsToSelector方法可以判断一个对象是否实现了某个方法（需要注意方法名不是”onClick”而是“onClick:”，冒号也是方法名的一部分）；

属性中的nonatomic：指定合成的存取方法是否为原子操作。所谓原子操作，主要指是否线程安全。

属性中的retain：retain指示符定义属性时，当把某个对象赋值给该属性时，该属性原来所引用的计数减 1，被赋值对象的引用计数加 1。

main.m

#import <Foundation/Foundation.h>  
#import "LCButton.h"  
#import "LCListener.h"  
  
int main(int argc, const charchar * argv[]) {  
    @autoreleasepool {  
          
        LCButton *button = [[LCButton alloc]init];  
        LCListener *listener = [[LCListener alloc]init];  
        button.delegate = listener;  
        [button click];  
        /* 结果： 
         Invoke KCButton's click method. 
         Invoke MyListener's onClick method.The button is:<KCButton: 0x1001034c0>. 
         */  
    }  
    return 0;  
}

 

代码块Block

在C#异步编程时我们经常进行函数回调，由于函数调用是异步执行的，我们如果想让一个操作执行完之后执行另一个函数，

则无法按照正常代码书写顺序进行编程，因为我们无法获知前一个方法什么时候执行结束，

此时我们经常会用到匿名委托或者lambda表达式将一个操作作为一个参数进行传递。其实在ObjC中也有类似的方法，称之为代码块（Block）。

Block就是一个函数体（匿名函数），它是ObjC对于闭包的实现，在块状中我们可以持有或引用局部变量（不禁想到了lambda表达式），

同时利用Block你可以将一个操作作为一个参数进行传递（是不是想起了C语言中的函数指针）。在下面的例子中我们将使用Block实现上面的点击监听操作：

 

LCButton.h</span>
#import <Foundation/Foundation.h>  
@class LCButton;  
typedef void (^LCButtonClick)(LCButton *);  
  
@interface LCButton : NSObject  
  
#pragma mark - 属性  
#pragma mark 点击操作属性  
@property (nonatomic,copy) LCButtonClick onClick;  
//上面的属性定义等价于下面的代码  
//@property (nonatomic,copy) void(^ onClick)(LCButton *);  
  
#pragma mark - 公共方法  
#pragma mark 点击方法  
-(void)click;  
@end

LCButton.m  

#import "LCButton.h"  
@implementation LCButton  
  
-(void)click{  
    NSLog(@"Invoke LCButton's click method.");  
    if (_onClick) {  
        _onClick(self);  
    }  
}  
@end

上面代码中使用Block同样实现了按钮的点击事件，关于Block总结如下：

1. Block类型定义：返回值类型(^ 变量名)(参数列表)（注意Block也是一种类型）；
2. Block的typedef定义：返回值类型(^类型名称)(参数列表)；
3. Block的实现：^(参数列表){操作主体}；
4. Block中可以读取块外面定义的变量但是不能修改，如果要修改那么这个变量必须声明_block修饰；

 

main.m


#import <Foundation/Foundation.h>  
#import "LCButton.h"  
  
  
int main(int argc, const charchar * argv[]) {  
  
    LCButton *button = [[LCButton alloc]init];  
    button.onClick = ^(LCButton *btn){  
        NSLog(@"Invoke onClick method.The button is:%@.",btn);  
    };  
    [button click];  
    /*结果： 
     Invoke LCButton's click method. 
     Invoke onClick method.The button is:<LCButton: 0x1006011f0>. 
     */  
      
      
    return 0;  
}

 

分类Category

当我们不改变原有代码为一个类扩展其他功能时我们可以考虑继承这个类进行实现，但是这样一来使用时就必须定义成新实现的子类才能拥有扩展的新功能。如何在不改变原有类的情况下扩展新功能又可以在使用时不必定义新类型呢？我们知道如果在C#中可以使用扩展方法，其实在ObjC中也有类似的实现，就是分类Category。利用分类，我们就可以在Objective-C中动态的为已有类添加新的行为（特别是系统或框架中的类）。在C#中字符串有一个Trim()方法用于去掉字符串前后的空格，使用起来特别方便，但是在Objective-C中却没有这个方法，这里我们不妨通过Category给NSString添加一个stringByTrim()方法：

 

NSString+Extend.h
  
#import <Foundation/Foundation.h>  
//@interface 已有类 (类别名)  
@interface NSString (Extend)  
-(NSString *)stringByTrim;  
@end  

NSString+Extend.m  
#import "NSString+Extend.h"  
@implementation NSString (Extend)  
-(NSString *)stringByTrim{  
    NSCharacterSet *character = [NSCharacterSet whitespaceCharacterSet];  
    return [self stringByTrimmingCharactersInSet:character];  
}  
@end 
 

main.m

#import <Foundation/Foundation.h>  
#import "NSString+Extend.h"  
int main(int argc, const charchar * argv[]) {  
NSString *name = @" Bright Li ";  
    name = [name stringByTrim];  
    NSLog(@"I'm %@!",name);//结果：I'm Bright Li   
return 0;  
}

     通过上面的输出结果我们可以看出已经成功将@” bright Li  ”两端的空格去掉了。分类文件名一般是“原有类名+分类名称”，分类的定义是通过在原有类名后加上”(分类名)”来定义的（注意声明文件.h和实现文件.m都是如此）。