Objective-C基础学习笔记(七)－分类-Category-类的本质-load和+initialize方法-SEL数据

一、分类-Category

1.思考：如何在不改变原来类的模型的前提下，扩展分类的方法？

两种方式：

1》继承：子类可继承父类原有的方法，并且增加自己的方法.

2》分类;  可以给某个类扩 充方法（不修改原来的代码）

2.分类的使用格式

 1》分类的声明

@interface 类名 (分类名称)

// 方法声明

@end

 2》分类的实现

@implementation类名 (分类名称)

// 方法实现

@end

分类使用示例：

给NSString类添加一个类方法，计算某字符串中阿拉伯数字的个数 

#import <Foundation/Foundation.h>

@interface NSString (number)
/* 给NSString类添加一个类方法，计算某字符串中阿拉伯数字的个数 */
+ (int)numberCountOfString:(NSString *)str;
/* 对象方法 自己的数字个数不用参数了*/
- (int)numberCount;
@end

#import "NSString+number.h"

@implementation NSString (number)
+ (int)numberCountOfString:(NSString *)str
{
    int count = 0;
//    if (nil == str)
//    {
//        return 0;
//    }
//    for (int i = 0;i < str.length; i++ )
//    {
//        unichar c =  [str characterAtIndex:i];
//        if ((c >= '0') && (c <= '9'))
//            count++;
//    }
    count = [str numberCount];
    return count;
}

- (int)numberCount;
{
    int count = 0;
    for (int i = 0; i < self.length;i++)
    {
        unichar c = [self characterAtIndex:i];
        if ((c >= '0') && (c <= '9'))
            count++;
    }
    return count;

}
@end

代码测试：

int main()
{
    // 扩展类方法的调用
    int count1 = [NSString numberCountOfString:@"1fh2hg3 h456d78"];
    NSLog(@"1fh2hg3 h456d78 has %d num ",count1);
    
    // 分析：这个方法不好还得用类的形式调用，改进用对象方法
    // 扩展对象方法的调用
    int count2 = [@"123asdfg456" numberCount];
    NSLog(@"123asdfg456 has %d num ",count2);
    
    return 0;
}

2015-03-23 14:53:39.922 catgory分类[1042:96183] 1fh2hg3 h456d78 has 8 num 

2015-03-23 14:53:39.922 catgory分类[1042:96183] 123asdfg456 has 6 num 

分类总结：

分类作用：

 再不改变原来类内容基础上增加一些方法；

 

好处：

一个庞大的类 可以分模块开发

一个庞大的类可以有多个人编写，有利于团队合作

 

注意：

 1. 分类不能扩充成员变量：
 2. 分类方法实现中可以访问成员变量
 3. 分类可以重新实现原来类中的方法，但会覆盖掉原来的方法，导致原来的方法中没法使用
 4. 方法调用优先级：分类（后编译的）－》原来类－》父类
 

还有一个问题，多个分类同时重新实现一个方法那么调用哪个呢？

哪个.m后编译，就会覆盖掉之前编译的，可在xcode中调整。

二 .类的本质

类本身也是一个对象，是个class类型的对象，简称类对像，他只在内存中存在一份。

 Class类型的定义  typedefstruct objc_class *Class;

类名就代表着类对象，每个类只有一个类对象。

2.通过代码类理解类的本质

Person类的声明,声明了一个类方法

 
#import <Foundation/Foundation.h>

@interface Person : NSObject
{
    int _age;
}
@property int age;

+ (void)test;

@end
 

Person类的实现

 

#import "Person.h"

@implementation Person
+ (void)test
{
    NSLog(@"调用了类的类方法test方法");
}

@end

主函数：

int main()
{

    /* p1 p2 都指向创建的Person类的对象*/
    Person *p1 = [[Person alloc] init];
    Person *p2 = [[Person alloc] init];

    
    /* 获取内存中类对象的两种方式 都返回Person这个类在内存中的地址 */
    
    // 1.调用对象的class 方法
    Class c = [p1 class];
    Class c2 = [p2 class];
    
    // 2.调用类的class方法
    Class c3 = [Person class];
    
    NSLog(@"c = %p c2 = %p c3 =%p",c,c2,c3);
    // 结果c1 = c2 = c3 说明同一个类在内存中只有一个
    
    /* 类名就是类对象 和class返回的类对象是一样的 */
    [Person test];
    [c3 test];
    
    // 类对象 ＝ 类名 也可以创建对象
    Person *p3 = [[c alloc] init];
    p3.age = 100;
    NSLog(@"p3 age %d",p3.age);
    
    return 0;
}

2015-03-23 15:22:22.457类的本质[1109:104403] c = 0x1000025d8 c2 = 0x1000025d8 c3 =0x1000025d8

2015-03-23 15:22:22.457类的本质[1109:104403]调用了类的类方法test方法

2015-03-23 15:22:22.458类的本质[1109:104403]调用了类的类方法test方法

2015-03-23 15:22:22.458类的本质[1109:104403] p3 age 100

三 .   +load和+initialize方法

＋load

1. 程序启动时就会加载项目中所有的类和分类，并调用每个类和分类的＋load方法，  只会调用一次

2. 先加载父类在加载子类最后加载分类，也就是先调用父类的+load方法，在调用子类的＋load方法,最后加载分类的＋ load方法，

3.不管程序运行过程中有没有用到这个类，都会加载，且只加载一次

   

＋initialize

1.当第一次使用某个类时(比如创建对象)，就会调用当前类的initialize方法

2.先初始化父类在初始化子类，先调用父类的initialize方法在调用子类的initalize方法，只会初始化一次；

  分类也会加载，但是用的时候优先使用分类的initialize方法不会加载原类的initlize方法。

3.使用了initalize方法就可以监听什么时候使用了类

 +load和+initialize方法的调用过程代码示例：

先说明一下用到的几个类的关系：

Person类继承于OBJect类，并且又增加了分类，Student类继承于Person类。

Person类的声明同上文：

Person类的实现：

#import "Person.h"

@implementation Person
+ (void)test
{
    NSLog(@"调用了类的类方法test方法");
}
/* 重写了load方法：只要程序运行就会加载一次仅此一次 */
+ (void)load
{
    NSLog(@"Person load!!");
}
/* 重写了initialize方法：只在用到的时候会调用*/
+ (void)initialize
{
    NSLog(@"Person initialize!!");
}
@end

Person类的分类声明：

#import "Person.h"

@interface Person (loadTest)

@end

Person类的分类的实现：

#import "Person+loadTest.h"

@implementation Person (loadTest)
/* 重写了load方法：只要程序运行就会加载一次仅此一次 */
+ (void)load
{
    NSLog(@"Person+loadTest load!!");
}
/* 重写了initialize方法：只在用到的时候会调用*/
+ (void)initialize
{
    NSLog(@"Person+loadTest initialize!!");
}
@end

Student类的声明：1#import"Person.h"

/* Student类的声明 继承于Person类*/
@interface Student : Person

@end

Student类的实现：

#import "Student.h"

@implementation Student
/* 重写了load方法：只要程序运行就会加载一次仅此一次 */

+ (void)load
{
    NSLog(@"Student load!!");
}
/* 重写了initialize方法：只在用到的时候会调用*/
+ (void)initialize
{
    NSLog(@"Student initialize!!");
}
@end

+load和+initialize方法的调用过程测试代码：

1.什么也不执行，查看调用的过程？

int main()
{
    return 0;
}

2015-03-23 15:42:40.415类的本质[1246:110623] Person load!!

2015-03-23 15:42:40.417类的本质[1246:110623] Student load!!

2015-03-23 15:42:40.417类的本质[1246:110623] Person+loadTest load!!

从打印的结果可见：

不管程序运行过程有没有用到这个类，都会调用+load加载进内存，加载的顺序是，先加载父类在加载子类最后加载分类，只加载一次。

2.程序运行过程中只使用Person这个类，查看调用的过程？

int main()
{
    // 只是用Person这个类
    [[Person alloc] init];
    return 0;
}

2015-03-23 15:47:35.384 类的本质[1254:112282] Person load!!

2015-03-23 15:47:35.385 类的本质[1254:112282] Student load!!

2015-03-23 15:47:35.385 类的本质[1254:112282] Person+loadTest load!!

2015-03-23 15:47:35.386 类的本质[1254:112282] Person+loadTest initialize!!

从打印的结果可见：

加载过程同上，当使用了这个Person类时，优先使用分类的initialize方法不会加载原类的initlize方法，由于没使用子类并不会初始化子类。

3.使用子类

 

int main()
{
    //程序启动时就会加载项目中所有的类，不管用不用
    // 使用Student类
    [[Student alloc] init];
    return 0;
}

2015-03-23 15:52:42.834 类的本质[1268:113796] Person load!!

2015-03-23 15:52:42.836 类的本质[1268:113796] Student load!!

2015-03-23 15:52:42.836 类的本质[1268:113796] Person+loadTest load!!

2015-03-23 15:52:42.837 类的本质[1268:113796] Person+loadTest initialize!!

2015-03-23 15:52:42.837 类的本质[1268:113796] Student initialize!!

从打印的结果可见：

先初始化父类在初始化子类，先调用父类的initialize方法在调用子类的initalize方法，只会初始化一次；分类也会加载，但是用的时候优先使用分类的initialize方法不会加载原类的initlize方法。

四.SEL数据

1. 方法在内存中的存储：

     每个方法在内存中都有一个SEL数据和它对应虚拟成下面的形式

     SEL s1 = +test 地址

     SEL s2 = -test 地址

2.Objective-C中调用函数的方法是“消息传递”，是利用performSelector传递一个sel类型的消息，再根据sel消息找到方法的地址进而去调用这个方法。

3.  SEL类型的定义

typedef struct objc_selector    *SEL;

4. SEL对象的创建

SEL s = @selector(test);

SEL s2 = NSSelectorFromString(@"test");

SEL使用示例：

Person类的声明

#import <Foundation/Foundation.h>

@interface Person : NSObject
/* 类里面包含方法列表 */
// 每个方法在内存中都有一个sel和他对应
+ (void)test1;
- (void)test2;
- (void)test3:(NSString *)str;
@end

Person类的实现：

#import "Person.h"

@implementation Person
+ (void)test1
{
    NSLog(@"test1");
}
- (void)test2
{
    // _cmd代表本方法
    // NSStringFromSelector方法接收sel类型的数据，并将其转化为字符串
    NSString *str = NSStringFromSelector(_cmd);
    /* 打印本方法名 */
    NSLog(@"In %@ function",str);
}
- (void)test3:(NSString *)str
{
    NSLog(@"In test3 传给我的字符串是 %@",str);
}
@end

sel的几种用法：

int main() 
{

    Person *p = [[Person alloc] init];
    
    // 直接调用test2方法
    [p test2];
    
    // 使用SEL调用方法的过程
    // 1.把test2包装成SEL类型的数据
    // 2.根据SEL数据找到对应的方法地址
    // 3.根据方法地址调用对应的方法

    [p performSelector:@selector(test2)];
    
    /* 方法名字符串调用方法 */
     NSString *name = @"test2";
    // 把字符串变成SEL
    SEL s2 = NSSelectorFromString(name);
    [p performSelector:s2];
  
    
    /* 带参数的方法调用 */
    // 方式一
    [p performSelector:@selector(test3:) withObject:@"hello sel"];
    
    // 方式二
    SEL s3 = @selector(test3:);
    [p performSelector:s3 withObject:@"123"];
    
    return 0;
}

2015-03-23 16:31:30.853 sel[1368:124580] In test2 function

2015-03-23 16:31:30.854 sel[1368:124580] In test2 function

2015-03-23 16:31:30.854 sel[1368:124580] In test2 function

2015-03-23 16:31:30.854 sel[1368:124580] In test3传给我的字符串是 hello sel

2015-03-23 16:31:30.855 sel[1368:124580] In test3传给我的字符串是 123

sel总结;

1 每个类的方法列表都存储在类对象中

2 每个方法都有一个与之对应的SEL类型的对象

3. 根据一个SEL对象就可以找到方法的地址，进而调用方法

4. 使用调用方法需要performSelector传递一个sel类型消息。
5. _cmd ：代表着当前方法的SEL

五.description方法

1. -description方法

使用NSLog和%@输出某个对象时，会调用对象的-description方法，并拿到返回值进行输出

2. + description方法

使用NSLog和%@输出某个类对象时，会调用类对象+description方法，并拿到返回值进行输出