objective-c中Category类别（扩展类）专题总结

objective-c类别的作用？
通过类别的方式，可以将类的实现分散到不同的文件里。

@interface  NSString(NumberConvenience)
-(NSNumber *)lengthAsNumber;
@end//NumberConvenience

这个声明有两个特点：
     (1)现有的类位于@interface关键字之后，其后是位于圆括号中的类别名称。类别名称是NumberConvenience，而且该类别将向NSString类中添加方法。换句话说：“我们向NSString类中添加一个名称为NumberConvenience的类别。”
        同名类别有唯一性，但是可以添加任意多的不同名类别。
     (2)可以执行希望向其添加类别的类以及类别的名称，还可以列出添加的方法
        不可以添加新的实例变量，类别生命中没有实例变量部分。
2、实现类别
    @implementation NSString(NumberConvenience)
    -(NSNumber *)lengthAsNumber
    {
        unsigned int length = [self length];
        return ([NSNumber numberWithUnsignedInt : length]);
    }  //lengthAsNumber
    @end   //NumberConvenience
在实现部分也包括类名、类别名和新方法的实现代码
3、类别的局限性
有两方面局限性：
    (1)无法向类中添加新的实例变量，类别没有位置容纳实例变量。
       (2)名称冲突，即当类别中的方法与原始类方法名称冲突时，类别具有更高的优先级。类别方法将完全取代初始方法从而无法再使用初始方法。

无法添加实例变量的局限可以使用字典对象解决

runtime 机制 为类别填加实例变量。

主要利用ObjectiveC的C API中函数:

void objc_setAssociatedObject(id object, const void *key, id value, objc_AssociationPolicy policy)

id objc_getAssociatedObject(id object, const void *key)

原理详细参见官方的ObjectiveC
Runtime Reference.

好了,现在直接写怎么做了.

1.在定义类别之前, 引入runtime.

#import <objc/runtime.h>

2.定义&实现类别(以UIView为例)

定义:

@interface UIView(AddVariables)

@property (nonatomic, retain) NSString *viewName;

@end

实现:

// 定义存取的Key

static const char *viewNameKey = "viewNameKey";

@implementation UIView(AddVariables)

// get方法

- (NSString *)viewName {

return (NSString *)objc_getAssociatedObject(self, viewNameKey);

}

// set方法

- (void)setViewName:(NSString *)newViewNameKey {

objc_setAssociatedObject(self, viewNameKey, newViewNameKey, OBJC_ASSOCIATION_RETAIN_NONATOMIC);

}

@end

3.调用测试:

- (void)viewDidLoad {

UIView *testView = [[UIView alloc] initWithFrame:self.view.bounds];

[self.view addSubview:testView];

[testView release];

[testView setViewName:@"Nori‘s View"];

NSLog(@"[testView‘s newPropery]:%@", testView.viewName);

[super viewDidLoad];

}

输出结果如下:

testView‘s newPropery:Nori‘s View

4、类别的作用
类别主要有3个作用：
       (1)将类的实现分散到多个不同文件或多个不同框架中。
       (2)创建对私有方法的前向引用。
       (3)向对象添加非正式协议。
二、利用类别分散实现
我们可以将类的接口放入头文件中，从而将类的实现放入.m文件中
但不可以将@implementation分散到多个不同的.m文件中，使用类别可以完成这一工作
利用类别，可以将一个类的方法组织到不同的逻辑分组中，使编程人员更加容易的阅读头文件
举例代码：
头文件CatagoryThing.h包含类的声明和一些类别，导入Foundation框架，然后带有3个整型变量的声明

#import<Foundation/Foundation.h>
@interface CategoryThing : NSObject {
   int thing1;
   int thing2;
   int thing3;
}
@end // CategoryThing

类声明之后是3个类别，每个类别具有一个实例变量的访问器，将这些实现分散到不同的文件中

@interface CategoryThing(Thing1)
- (void) setThing1: (int) thing1;
- (int) thing1;
@end // CategoryThing (Thing1)

@interface CategoryThing (Thing2)
- (void) setThing2: (int) thing2;
- (int) thing2;
@end // CategoryThing (Thing2)

@interface CategoryThing (Thing3)
- (void) setThing3: (int) thing3;
- (int) thing3;
@end // CategoryThing (Thing3)

类别可以访问其继承的类的实例变量，类别的方法具有最高的优先级
类别可以分散到不同文件中，甚至不同框架中

三、使用类别创建前向引用
如果其他类中的方法未实现，在你访问其他类的私有方法时编译器报错
这时使用类别，在类别中声明这些方法（不必提供方法实现），编译器就不会再产生警告

四、非正式协议和委托类别
Cocoa中的类经常使用一种名为委托(delegate)的技术
委托是一种对象，另一个类的对象会要求委托对象执行他的某些操作
（看不懂，在实践中学习）

#import <Foundation/Foundation.h>

#import "ITunesFinder.h"

int main
(int argc, const char *argv[])

{

NSAutoreleasePool *pool;

pool = [[NSAutoreleasePool alloc] init];

NSNetServiceBrowser*browser;

browser = [[NSNetServiceBrowseralloc] init];

ITunesFinder *finder;

finder = [[ITunesFinder alloc] init];//因为finder是alloc方法创建的，必须在不适用这个对象时将其释放

[browser setDelegate:finder];//告知browser使用finder作为委托对象

[browser searchForServicesOfType: @"_daap._tcp" //告知browser对象使用TCP协议去搜索DAAP类型服务

inDomain: @"local."];//表示只搜索本地

NSLog (@"begun
browsing");//表示下面的run循环已经开始

[[NSRunLoop currentRunLoop] run];//run循环是一种Cocoa构造，他不执行任何处理，等待用户的操作

[browser release];//run方法将一直保持运行而不返回，所以包含此行之后的代码不会被运行

[finder release];

[pool release];

return (0);

} // main

创建一个NSObject的类别称为“创建一个非正式协议”，因为可以作为任何类的委托对象使用

响应选择器
选择器只是一个方法名称，但它以Objective-C运行时使用特殊方式编码，以快速执行查询
可以使用@selector()预编译指定选择器，其中方法名位于圆括号中
例如之前的Car类的setEngine:方法的选择器是：@selector(setEngine:)
而Car类的setTire:atIndex；方法的选择器如下所示：@selector(setTire:atIndex;)

NSObject提供了一个名为respondsToSelector方法，该方法询问对象以确定其是否能够响应某个特定的消息
举例代码:
Car *car = [[Car alloc] init];
if([carrespondsToSelector:@selector(setEngine:)]){
NSLog(@"hihi");

}
选择器的其他应用
选择器可以被传递，可以作为方法的参数使用，甚至可以作为实例变量存储

小结
类别提供了向现有类添加新方法的手段，即使没有这些类的源代码
类别可以将对象的实现分散到多个不同的源文件、甚至多个不同的框架中
使用类别可以声明非正式协议，非正式协议是NSObject的一个类别，他可以列出对象能够响应的方法
非正式协议用于委托，委托是一种允许轻松定制对象行为的技术

NSMutableDictionary *dict;
dict=[NSMutableDictionary dictionary];

//使用键@“hello”将整值5添加到字典中的代码如下
[dict setObject:[@"hello" lengthAsNumber] forKey: @"hello"];

[dict setObject:[@"iLikeFish" lengthAsNumber] forKey: @"iLikeFish"];

[dict setObject:[@"Once upon a time" lengthAsNumber] forKey: @"Once upon a time"];

NSLog(@"%@",dict);

CategoryThing *thing;
thing= [[CategoryThing alloc] init];

[thing setThing1:5];
[thing setThing2:23];
[thing setThing3:42];

NSLog(@"Thing are %@!",thing);

[thing release];

[pool drain];
    return 0;
}
//
//  CategoryThing.h
//  S12_leibie
//
//  Created by cwity on 11-5-17.
//  Copyright 2011 __MyCompanyName__. All rights reserved.
//
#import <Cocoa/Cocoa.h>
@interface CategoryThing : NSObject {
int thing1;
int thing2;
int thing3;
}
@end
@interface CategoryThing (Thing1)
- (void) setThing1:(int) thing1;
- (int) thing1;
@end
@interface CategoryThing (Thing2)
- (void) setThing2:(int) thing2;
- (int) thing2;
@end
@interface CategoryThing (Thing3)
- (void) setThing3:(int) thing3;
- (int) thing3;
@end
//
//  CategoryThing.m
//  S12_leibie
//
//  Created by cwity on 11-5-17.
//  Copyright 2011 __MyCompanyName__. All rights reserved.
//
#import "CategoryThing.h"
@implementation CategoryThing
- (NSString *) description
{
NSString *desc;
desc= [NSString stringWithFormat:@"%d %d %d",
    thing1,thing2,thing3];

return (desc);
}
@end
//
//  Thing1.m
//  S12_leibie
//
//  Created by cwity on 11-5-17.
//  Copyright 2011 __MyCompanyName__. All rights reserved.
//
#import "CategoryThing.h"
@implementation CategoryThing (Thing1)
- (void) setThing1:(int)t1
{
thing1=t1;
}
- (int) thing1
{
return (thing1);
}
@end
//
//  Thing2.m
//  S12_leibie
//
//  Created by cwity on 11-5-17.
//  Copyright 2011 __MyCompanyName__. All rights reserved.
//
#import "CategoryThing.h"
@implementation CategoryThing (Thing2)
- (void) setThing2:(int)t2
{
thing2=t2;
}
- (int) thing2
{
return (thing2);
}
//
//  Thing3.m
//  S12_leibie
//
//  Created by cwity on 11-5-17.
//  Copyright 2011 __MyCompanyName__. All rights reserved.
//
#import"CategoryThing.h"
@implementation CategoryThing (Thing3)
- (void) setThing3:(int)t3
{
thing3=t3;
}
- (int) thing3
{
return(thing3);
}
@end

另外要特别注意的是，类别不能像继承时那样给类别接口增加新的实例变量，而是要扩展一个类的行为。
类别的名称是任意的。

类别是一种为现有的类添加新方法的方式。

类别有两方面的局限性。第一，无法向类中添加新的实例变量。类别没有位置容纳实例变量。

第二，名称冲突，即类别中的方法与现有的方法重名。当发生名称冲突时，类别具有更高的优先级。你的类别方法将完全取代初始方法，从而无法再使用初始方法。有些编程人员在自己的类别方法名中增加一个前缀，以确保不发生名称冲突。

说明   也有一些技术可以克服类别无法增加新实例变量的局限。例如，可以使用全局字典存储对象与你想要关联的额外变量之间的映射。但此时你可能需要认真考虑一下，类别是否是完成当前任务的最佳选择。

类别的作用

Cocoa中的类别主要用于3个目的：将类的实现分散到多个不同文件或多个不同框架中，创建对私有方法的前向引用，以及向对象添加非正式协议。如果你还不理解“非正式协议”（informal
protocol）的含义，请不要担心，我们稍后将简单地讨论这一概念。

@interface ClassB:ClassA         //ClassB类型继承ClassA类型
-(void) initVar;                //声明初始化方法,此方法重载ClassA中的同名方法
-(void) printVar;              //声明打印变量方法
@end
@implementation ClassB         //定义ClassB
-(void)initVar                           //定义初始化方法
{
x = 200;
}
-(void) printVar                        //定义打印变量方法
{
NSLog(@"x = %i", x);
}

int main(int argc, char *argv[])
{
NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init];
ClassB *b = [[ClassB alloc]init];     //定义ClassB类型实例
[b initVar];                                    //调用b对象的initVar方法
[b printVar];                                 //调用b对象的printVar方法
[b release];                                   //释放b对象占用的内存空间
[pool drain];
return 0;
}
-------------------------------------------------------------------------------
输出:
x = 200;
-------------------------------------------------------------------------------

接触过C++的同学看过上面的小例子，立刻就明白了，其实Objective-C的继承和C++继承的语法很类似，差别很小，都是在声明类型的时候多加一句代码，如ClassB类型继承ClassA类型，即在定义接口文件时编写:@interface ClassB:ClassA，即可完成继承。顺便提一句，Objective-C不能直接进行多继承，需要辅助协议(协议本质上类似与C#语言中的接口。关于协议的具体内容，将会在后面和分类概念一起介绍)实现多继承。
Objective-C中的方法重载也很简单，只要子类中的方法名称和父类的方法名称一样，即可自动对父类的同名方法进行重载，不用添加任何关键字。

类别声明： 
#import "ClassName.h" 
@interface ClassName ( CategoryName ) 
方法声明
@end
类别实现：
#import "ClassName+CategoryName.h” //声明文件 
@implementation ClassName ( CategoryName ) 
方法实现
@end
实例:
FractionMath.h
#import "Fraction.h"
@interface Fraction (Math)
-(Fraction*) add: (Fraction*) f;
-(Fraction*) mul: (Fraction*) f;
-(Fraction*) div: (Fraction*) f;
-(Fraction*) sub: (Fraction*) f;
@end
FractionMath.m
#import "FractionMath.h"
@implementation Fraction (Math)
-(Fraction*) add: (Fraction*) f {
return [[Fraction alloc] initWithNumerator: numerator * [f denominator] +denominator *
               [f numerator] denominator: denominator * [f denominator]];
}
-(Fraction*) mul: (Fraction*) f {
return [[Fraction alloc] initWithNumerator: numerator * [f numerator]
             denominator: denominator * [f denominator]];
}
-(Fraction*) div: (Fraction*) f {
return [[Fraction alloc] initWithNumerator: numerator * [f denominator] 
          denominator: denominator * [f numerator]];
}
-(Fraction*) sub: (Fraction*) f {
return [[Fraction alloc] initWithNumerator: numerator * [f denominator] -denominator * [f numerator]
                denominator: denominator * [f denominator]];
}
@end
main.m
#import <stdio.h>
#import "Fraction.h"
#import "FractionMath.h"
int main( int argc, const char *argv[] ) {
// create a new instance
Fraction *frac1 = [[Fraction alloc] initWithNumerator: 1 denominator: 3];
Fraction *frac2 = [[Fraction alloc] initWithNumerator: 2 denominator: 5];
Fraction *frac3 = [frac1 mul: frac2];
[frac1 print];
printf( " * " );
[frac2 print];
printf( " = " );
[frac3 print];
printf( "/n" );
// free memory
[frac1 release];
[frac2 release];
[frac3 release];
return 0;
}