oc 的分类-Category

通过分类(category)可以以模块的方式向现有的类添加方法。

它提供了一种简单的方式, 用它可以将类的定义模块化到相关方法的组或分类中。它还提供了扩展现有类定义的简便方式,并且不必访问类的源代码,也无需创建子类。 

/*
 文件名：Person.h
 */
#import <Foundation/Foundation.h>
@interface Person : NSObject
{
    int _age;
}
@property int age;
- (void)test;
@end

/*
文件名：Person.m
 */
#import "Person.h"
@implementation Person
- (void)test
{
    NSLog(@"Person-test");
}
@end

对于这段代码来说，如何在不改变原来类模型的前提下，给person类扩充一些方法？

有2种方式

继承，需要生成一个新类。

分类（Category），这样就不用使用继承，不用生成新类，分类依赖于已经存在的类。开发中很常用。不用修改原来类的代码。

分类的声明  在.h 文件
@interface 类名 (分类名称)
// 方法声明
@end

分类的实现在  .m 文件
@implementation 类名 (分类名称)
// 方法实现
@end

在 Xcode 里，可以自动生成分类，不用手写，新建 file，然后 oc-file， 分类选项即可。

好处

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

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

一般以模块命名分类（当然使用作者命名也可以）

//  Person+MJ.h
#import "Person.h"
@interface Person (MJ)
- (void)study;
@end

//  Person+MJ.m
#import "Person+MJ.h"
@implementation Person (MJ)
//分类只能增加方法，不能增加类成员变量
- (void)study
{
    //分类方法 实现 中，可以访问原来类中声明的成员变量_age
    NSLog(@"学习-----%d", _age);
}
- (void)test
//对于Person类固有的方法，分类可以重新实现原来类中的方法，但是会覆盖掉原来的方法，会导致原来的方法没法再使用，（不建议覆盖）
{
    NSLog(@"Person (MJ)-test");
}
@end

分类的作用：

在不改变原来类内容的基础上，可以为类增加一些方法

使用注意：

 1.分类只能增加方法，不能增加成员变量，如果实在想增加新的成员变量，那么可以通过继承实现。

 2.分类方法 实现 中 可以访问原来类中声明的成员变量，否则增加的新方法就没有意义了。

 3.分类可以重新实现原来类中的方法，但是会覆盖掉原来的方法，会导致原来的方法没法再使用（不建议覆盖）

 4.方法调用优先级：分类的方法 --> 原来类的方法  --> 父类的方法

优先去分类中查找，然后再去原来类中找，最后再去父类中找，如果有多个分类，且多个分类的里面的方法都覆盖了原类方法，那么调用顺序和编译顺序有关。看编译器先编译哪个文件，就先调用哪个文件的覆盖的方法。

单击—项目——出现Build Phases ——中的 Compile source 中查看：

编译的文件顺序，顺序可以人为改变。还发现，头文件是不被编译的，这就再次验证，头文件打酱油的特点，只是为了编程规范，所以之前，不写声明，直接写类的实现，不会报错的原因就是这样。

给系统自带的类添加分类

实际开发中，常常给系统自带的类添加分类，（系统自带的类无法修改，但是可以添加分类增加方法）不一定只是给自定义的类添加分类

这里再次说明：分类的名称，最好是按照模块命名（或者功能命名），让人一目了然。

给NSString增加一个类方法：计算某个字符串中数字的个数，再增加一个对象方法：计算当前字符串中数字的个数

//  NSString+Number.h
#import <Foundation/Foundation.h>
@interface NSString (Number)
+ (int)numberCountOfString:(NSString *)str;
- (int)numberCount;
@end

//  NSString+Number.m
#import "NSString+Number.h"
@implementation NSString (Number)
//  @"abc434ab43"
+ (int)numberCountOfString:(NSString *)str
{
    int count = 0;
    for (int i = 0; i<str.length; i++)
    {
        unichar c = [str characterAtIndex:i];
        if ( c>='0' && c<='9')
        {
            count++;
        }
    }
    return count;
}

- (int)numberCount
{
    int count = 0;
    for (int i = 0; i < self.length; i++)
    {
//取出 i 这个位置对应的字符
//typedef unsigned long NSUInteger
//返回字符串的索引 i 对应的字符
        unichar c = [self characterAtIndex:i];
        // 如果这个字符是阿拉伯数字
        if ( c>='0' && c<='9' )
        {
            count++;
        }
    }
    return count;
}
@end

//  main.m
#import <Foundation/Foundation.h>
#import "NSString+Number.h"
int main()
// 类库：很多类的集合
{
    // int count = [NSString numberCountOfString:@"54d43a43s43dasd"];
    int count = [@"9fdsfds543543" numberCount];
    NSLog(@"%d", count);
    return 0;
}

unichar 本质是：无符号短整型（有时候 char 类型当做 整数类型）

typedef unsigned short unichar;

在类方法里，+ (int)numberCountOfString:(NSString *)str;

我们可以不用写那么多代码来实现，而是依靠对象方法来实现，直接return [str numberCount];即可！

再次注意

• Category可以访问原始类的实例变量，但不能添加变量，只能添加方法。如果想添加变量，可以考虑通过继承创建子类
• Category可以实现原始类的方法，但不推荐这么做，因为它是直接替换掉原来的方法，这么做的后果是再也不能访问原来的方法
• 多个Category中如果实现了相同的方法，只有最后一个参与编译的才会有效

类的本质

其实类也是一个对象，是Class类型的对象，简称“类对象”，Class类型的定义：

typedef struct objc_class *Class;

类名就代表着类对象，每个类只有一个类对象，即，内存中只有一份类对象

+load 和 +initialize方法

+load方法：

在程序启动的时候会加载所有的类和分类，并调用所有类和分类的+load方法。先加载父类，再加载子类。也就是先调用父类的+load方法，再调用子类的+load方法。先加载原始类，再加载原始类的分类 。不管程序运行过程有没有用到这个类，都会调用+load加载 。

+initialize方法：

在第一次使用某个类时（比如创建对象等），就会调用一次+initialize方法，一个类只会调用一次+initialize方法，先调用父类的，再调用子类的。先加载原类，再加载分类

description方法

-description方法

使用NSLog和%@输出某个对象时，会调用-description方法，并拿到返回值进行输出，没有声明在 NSObject 头文件。

+ description方法

使用NSLog和%@输出某个类时，会调用+description方法，并拿到返回值进行输出，在 NSObject 类的头文件里

修改NSLog的默认输出

重写-description或者+description方法即可

死循环陷阱

如果在-description方法中使用NSLog打印self

/*文件名：Person.h */
#import <Foundation/Foundation.h>
@interface Person : NSObject
@property int age;
@property NSString *name;
@end

/*文件名：Person.m */
#import "Person.h"
@implementation Person
// 可以重写，决定了实例对象的输出结果
//- (NSString *)description
//{
//    // 下面代码会引发死循环
//    // NSLog(@"%@", self);

//    return [NSString stringWithFormat:@"age=%d, name=%@", _age, _name];
//}

// 决定了类对象的输出结果
+ (NSString *)description
{
    return @"Abc";
}
@end

//  main.m
#import <Foundation/Foundation.h>
#import "Person.h"

void test9()
{
    // 输出当前函数名
    NSLog(@"%s\n", __func__);
}

int main()
{
    // 输出行号
    NSLog(@"%d", __LINE__);

    // NSLog输出C语言字符串的时候，不能有中文，有中文的话无法输出，这是 NSLog 的缺点，如果有中文的 c 字符串，那么使用 printf 函数输出
    // NSLog(@"%s", __FILE__);

    // 输出源文件的名称
    printf("%s\n", __FILE__);

    test9();

    Person *p = [[Person alloc] init];

    // 指针变量的地址
    NSLog(@"%p", &p);

    // 对象的地址
    NSLog(@"%p", p);

    //打印 oc 对象，使用%@格式化，可以把对象所有属性全部打印
    //格式是 <类名：对象地址>
    NSLog(@"%@", p);

    return 0;
}

void test2()
{
    Class c = [Person class];

    // 1.会调用类的+description方法
    // 2.拿到+description方法的返回值（NSString *）显示到屏幕上
    NSLog(@"%@", c);
}

void test1()
{
    Person *p = [[Person alloc] init];
    p.age = 20;
    p.name = @"Jack";
    // 默认情况下，利用NSLog和%@输出对象时，结果是：<类名：内存地址>

    // 1.会调用对象p的-description方法
    // 2.拿到-description方法的返回值（NSString *）显示到屏幕上
    // 3.-description方法默认返回的是“类名+对象的内存地址”
    NSLog(@"%@", p);

    //Person *p2 = [[Person alloc] init];
    //NSLog(@"%@", p2);

    //NSString *name = @"Rose";

    //NSLog(@"我的名字是%@", name);

    Person *p2 = [[Person alloc] init];
    p2.age = 25;
    p2.name = @"Jake";

    NSLog(@"%@", p2);
}

SEL数据类型

方法的存储位置

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

每个方法都有一个与之对应的SEL类型的数据

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

SEL类型的定义

typedef struct objc_selector     *SEL;

SEL其实是对方法的一种包装，将方法包装成一个SEL类型的数据，去找对应的方法地址。找到方法地址就可以调用方法，其实发送的消息就是SEL

/*文件名：Person.h */
#import <Foundation/Foundation.h>
@interface Person : NSObject
+ (void)test;
- (void)test2;
- (void)test3:(NSString *)abc;
@end

/* 文件名：Person.m */
#import "Person.h"
@implementation Person
+ (void)test
{
    NSLog(@"test-----");
}

- (void)test2
{
    // _cmd代表着当前方法
    NSString *str = NSStringFromSelector(_cmd);

    // 会引发死循环
    // [self performSelector:_cmd];

    NSLog(@"调用了test2方法-----%@", str);
}

- (void)test3:(NSString *)abc
{
    NSLog(@"test3-----%@", abc);
}
@end

//  main.m
/*
SEL其实是对方法的一种包装，将方法包装成一个SEL类型的数据，去找对应的方法地址。找到方法地址就可以调用方法，其实发送的消息就是SEL
 */
#import <Foundation/Foundation.h>
#import "Person.h"

int main()
{
    Person *p = [[Person alloc] init];
    [p test2];

//    NSString *name = @"test2";
//    SEL s = NSSelectorFromString(name);
//    [p performSelector:s];

    // 间接调用test2方法
    //[p performSelector:@selector(test2)];

    //[p test3:@"123"];

//    SEL s = @selector(test3:);
//
//    [p performSelector:s withObject:@"456"];

    //[p test2];

    // 1.把test2包装成SEL类型的数据
    // 2.根据SEL数据找到对应的方法地址
    // 3.根据方法地址调用对应的方法
    return 0;
}

SEL对象的创建

SEL s = @selector(test);

SEL s2 = NSSelectorFromString(@"test");

SEL对象的其他用法

// 将SEL对象转为NSString对象

NSString *str = NSStringFromSelector(@selector(test));

Person *p = [Person new];

// 调用对象p的test方法

[p performSelector:@selector(test)];

NSLog输出增强

• __FILE__ ：源代码文件名
• __LINE__ ：NSLog代码在第几行
• _cmd ：代表着当前方法的SEL

// 下面的代码会引发死循环
- (void)test {
    [self performSelector:_cmd];
}

辛苦的劳动，转载请注明出处，谢谢……

http://www.cnblogs.com/kubixuesheng/p/4314169.html