黑马程序员－分类（category）

 分类

1 分类就是类的补充和扩展，本质上是类的一部分，把一个类分成若干部分，每个部分就是分类。

2 语法

* 文件中的语法@interface 主类类名（分类类名）

* 文件名通常为：主类名+分类名

* 调用方法时，只需要向主类引用放送消息即可

3 使用分类的方式

* 可以给一个类增加功能（增加方法）

* 将类分成若干部分

* 分类不但可以给自定义的类添加功能，还可以给不知道源代码的类添加功能。

* 在分类中，不可以定义实例变量，也不可以定义属性，可以访问对象的属性。

* 在运行时，分类中的方法与类原有的方法并无区别，其代码可以访问包括私有类成员变量在内的所有成员变量。

* 若分类声明了与类中原有方法同名的函数，则分类中的方法会被调用。因此分类不仅可以增加类的方法，也可以代替原有的方法。这个特性可以用于修正原有代码中的错误，更可以从根本上改变程序中原有类的行为。若两个分类中的方法同名，则被调用的方法是不可预测的。

通常来讲，分类是定义在.h文件中，但也可以定义.m文件中，此时分类的方法就变成私有方法

//Fraction声明 

#import <Foundation/Foundation.h>

@interface Fraction : NSObject

{

    int _numerator;

    int _denominator;

}

@property (nonatomic,assign) int numerator;

@property (nonatomic,assign) int denominator;

- (void) setNumerator:(int)numerator andDemominator:(int)denominator;

- (void) reduce;

- (Fraction *) add:(Fraction *)fraction;

- (double) convertToNum;

- (void) print;

@end

// Fraction类实现  

#import "Fraction.h"

@implementation Fraction

- (void)setNumerator:(int)numerator andDemominator:(int)denominator

{

    _numerator = numerator;

    _denominator = denominator;

    [self reduce];

}

- (void)reduce

{

    int num = _numerator;

    int dem = _denominator;

    int temp;

    

    while (dem) {

        temp = num%dem;

        num = dem;

        dem = temp;

    }

    

    _numerator /= dem;

    _denominator /= dem;

}

-(Fraction *)add:(Fraction *)fraction

{

    _numerator = _numerator*fraction.denominator + _denominator*fraction.numerator;

    _denominator = _denominator*fraction.denominator;

    [self reduce];

    return self;

}

- (double)convertToNum

{

    double convert = _numerator/_denominator;

    return convert;

}

-(void)print

{

    NSLog(@"%i/%i",_numerator,_denominator);

}

@end

//Fraction类的FrozenMathOps分类声明 

#import "Fraction.h"

@interface Fraction (FrozenMathOps)

- (Fraction *) add:(Fraction *)fraction;

- (Fraction *) mul:(Fraction *)fraction;

- (Fraction *) sub:(Fraction *)fraction;

- (Fraction *) div:(Fraction *)fraction;

- (void) fra;

@end

 

//Fraction类的FrozenMathOps分类实现  

#import "Fraction+FrozenMathOps.h"

@implementation Fraction (FrozenMathOps)

- (Fraction *)add:(Fraction *)fraction

{

    _numerator = _numerator*fraction.denominator + _denominator*fraction.numerator;

    _denominator = _denominator*fraction.denominator;

    [self reduce];

    return self;

}

- (Fraction *) mul:(Fraction *)fraction

{

    _numerator = _numerator*fraction.denominator - _denominator*fraction.numerator;

    _denominator = _denominator*fraction.denominator;

    [self reduce];

    return self;

}

- (Fraction *)sub:(Fraction *)fraction

{

    _numerator = _numerator*fraction.numerator;

    _denominator = _denominator*fraction.denominator;

    [self reduce];

    return self;

}

- (Fraction *)div:(Fraction *)fraction

{

    _numerator = _numerator*fraction.denominator;

    _denominator = _denominator*fraction.numerator;

    [self reduce];

    return self;

}

- (void)fra

{

    NSLog(@"frozen");

}

@end

 

// Fraction类的o分类声明 

#import "Fraction.h"

@interface Fraction (o)

- (void) fra;

@end

// Fraction类的o分类实现 

#import "Fraction+o.h"

@implementation Fraction (o)

- (void)fra

{

    NSLog(@"o");

}

@end

//主头文件 

#import <Foundation/Foundation.h>

#import "Fraction.h"

#import "Fraction+FrozenMathOps.h"

#import "Fraction+o.h"

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

    @autoreleasepool {

        

        Fraction *fra = [[Fraction alloc] init];

        [fra fra];

    }

    return 0;

}

输出结果与编译的顺序有关，编译靠后的分类“特权高”，即分类方法名相同，执行编译靠后的分类。方法的优先顺序为

分类(后编译分类>先编译分类)>该类>父类 

协议

1 协议就是规则，定义一个协议就相当于制定规则。

OC中类遵守协议，就相当于拥有了一种能力。

2 语法

＠protocol协议名

           @required声明必须遵守的属性和方法

           @optional声明可选的属性和方法

           默认@required

3 一个类遵守一个协议

@interface 类名（分类名）：父类名 <协议名>

4 使用协议类型的引用指向实现了协议或者遵守了协议的对象，id<TRProtocal> p = [[MyClass] init];

[p ];可以向协议的引用发送消息，只能发送协议要求的消息

5 协议的继承相当于协议的合并

6 一个类可以同时遵守多个协议，协议之间用"，"号分开

7 如果一个类遵守一个协议，那么它的子类也遵守。

8 协议的使用和多态相类似，可以用作数组、参数、返回值类型，只不过多态返回的对象，一定要有继承关系，协议类型返回的对象，一定要有遵守协议或实现协议。

3.代理模式

（由别人帮自己实现某个功能的模式称为代理模式）

1）接受代理

@ interface 类名：父类名 <协议名>（多个协议之间用逗号隔开）

….

@end

2)确认协议

@implementation类名

协议方法

{

}

@end

（代理是谁，谁接受并确认协议）

4.注意

1）协议声明了可以被任何类实现的方法。

2）协议定义了一个其他对象可以实现的接口。