注册 登录  
 加关注
   显示下一条  |  关闭
温馨提示!由于新浪微博认证机制调整,您的新浪微博帐号绑定已过期,请重新绑定!立即重新绑定新浪微博》  |  关闭

还东国的博客

行之苟有恒,久久自芬芳

 
 
 

日志

 
 

(转载)Objective -C的开发之八扩展类Category  

2016-01-21 22:14:49|  分类: IOS |  标签: |举报 |字号 订阅

  下载LOFTER 我的照片书  |

(转载)Objective -C的开发之八扩展类Category


http://www.mamicode.com/info-detail-471336.html


类别

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

利用Objective-C的动态运行时分配机制,可以为现有的类添加新方法,这种为现有的类添加新方法的方式称为类别catagory,他可以为任何类添加新的方法,包括那些没有源代码的类。

类别使得无需创建对象类的子类就能完成同样的工作

一、创建类别

1、声明类别

声明类别与声明类的形式很相似

@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)名称冲突,即当类别中的方法与原始类方法名称冲突时,类别具有更高的优先级。类别方法将完全取代初始方法从而无法再使用初始方法。

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

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, c*****t 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的一个类别,他可以列出对象能够响应的方法


非正式协议用于委托,委托是一种允许轻松定制对象行为的技术


 


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


 


 @interface NSString (NumberConvenience)


- (NSNumber *)lengthAsNumber;


@end


(1)为NSString类添加一个名称为NumberConveniencede的类别;类别名称具有唯一性,你可以向一个类中添加任意多的类别。


(2)可以指定希望向其添加类别的类(NSString),以及类别的名称(NumberConvenience),而且你还可以列出添加的方法,最后以@end结束;类别声明部分不能有实例变量部分。


实现类别


@implementation NSString (NumberConvenience)


- (NSNmuber *)lengthAsNumber{


       unsigned int length = [self length];//获得字符串长度


       return ([NSNumber numberWithUnsignedInt :length]);



@end


#import <Foundation/Foundation.h>


#import "CategoryThing.h"


//类别的作用:


//(1)将类别实现分散到多个不同文件或多个不同框架中


//(2)创建私有方法的前向引用


//(3)向对象添加非正式协议


//类别的局限性:


//(1)无法添加新的实例变量


//(2)名称冲突,如果类别和现有的方法重名,类别具有更高的优先级,解决办法,类别方法名中添加一个前缀


@interface NSString (NumberConvenience)


- (NSNumber *) lengthAsNumber;


@end


@implementation NSString (NumberConvenience)


- (NSNumber *) lengthAsNumber


{


unsigned int length= [self length];


return ([NSNumber numberWithUnsignedInt:length]);


}


@end


int main (int argc, c*****t char * argv[]) {


//我们适用类别创建的所有NSNumber类的对象将在自动释放池中被销毁一样,可变字典也将在这里被销毁


NSAutoreleasePool * pool = [[NSAutoreleasePool alloc] init];


// insert code here...

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


 


 


objective-c中类别(扩展类)专题总结


什么时候使用类别?


(1)类别只能添加新方法,无法添加新的实例变量(2)如果类别名和原来类中的方法产生名称冲突,则类别将覆盖原来的方法,因为类别具有更高的优先级。


要注意的是Objective-c只支持单继承,如果要实现多继承的话,可以通过类别和协议的方式来实现。


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


类别的名称是任意的。


创建类别


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


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


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


中增加一个前缀,以确保不发生名称冲突。


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


最佳选择。


类别的作用


Cocoa中的类别主要用于3个目的:将类的实现分散到多个不同文件或多个不同框架中,创建对私有方法的前向引用,以及向对象添加非正式协议。如果你还不理解“非正式协议”(informal protocol


)的含义,请不要担心,我们稍后将简单地讨论这一概念。


 


Objective-C 类的继承、方法重载


这次,我们讲解在Objective-C中如何进行类的继承以及方法的重载。按照惯例,我们还是先拿出一个重载的小例子,以例子为基础展开讲解。


#import <Foundation/Foundation.h>


@interface ClassA:NSObject        //ClassA类型继承NSObject类型


{


int x;                                         //声明变量成员


}


-(void) initVar;                          //声明初始化方法


@end


@implementation ClassA          //定义ClassA


-(void) initVar                           //定义初始化方法


{


x = 100;


}


@end


 


@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中的方法重载也很简单,只要子类中的方法名称和父类的方法名称一样,即可自动对父类的同名方法进行重载,不用添加任何关键字。


 


 


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, c*****t 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;


}


 


类别 (又叫类的扩展)


@interface   类名  (类别名)   //类别名可以随便取


例如:在.m文件中这样写。   @interface TEST_DRAW_APPViewController (ViewHandlingMethods)   //此处是类别,又叫类扩展


类别要解决的问题是:为现有的类增加新行为


子类是一种办法,但是面对类簇和工具包或类库时确没有能力为力


类别解决了这个问题。


创建类别:类别是一种为现有类提供新方法的方式。


类别与扩展


category 下称类别允许你甚至在没有类源码的情况下扩展一个类的功能,给它增加方法。


主要作用是使相同的方法在没有继承关的类中复用。


。对框架提供类的扩展(没有源码,不能修改)。


2。 不想生成一个新的子类的情况下,比如对 NSArray 的扩展。


3。 方便做项目管理,可以将一份源码在多个地方共享或者做方法版本管理、多人协作开发、用本地版本替换公共版本实现。


不建议在 category 中覆盖类中的方法,因为在 category 中的方法不能调用 superClass 的方法(因为没有元数据支持)


category 方法不能覆盖于同一class 的其它 category 中的方法。因为不法预知他们的加载优先顺序,就可能在编译时出错。


对类库的 category 方法覆盖对导致整个类库的行为发生变化,因此调用那些方法的类不知道方法的实现已经发生了变化。


警告:


虽然 category 不限于任何 class ,但是仍然不建议编写针对 rootClass 的 category。 原因是影响面较大,其它开发人员如果不注意的话就会出问题。


而且类对象也可能调用这些方法,甚至在调用时的 self 指针不是实例而是类对象本身。


类别的作用


通过类别的方式,可以将类的实现分散到不同的文件里。


 


Objective-C 2.0中的Category语法 ,Category提供了一种比继承(inheritance)更为简洁的方法来对class进行扩展,我们可以为任何已经存在的class添加方法。

  评论这张
 
阅读(364)| 评论(0)
推荐 转载

历史上的今天

在LOFTER的更多文章

评论

<#--最新日志,群博日志--> <#--推荐日志--> <#--引用记录--> <#--博主推荐--> <#--随机阅读--> <#--首页推荐--> <#--历史上的今天--> <#--被推荐日志--> <#--上一篇,下一篇--> <#-- 热度 --> <#-- 网易新闻广告 --> <#--右边模块结构--> <#--评论模块结构--> <#--引用模块结构--> <#--博主发起的投票-->
 
 
 
 
 
 
 
 
 
 
 
 
 
 

页脚

网易公司版权所有 ©1997-2017