object-c的protocol(协议）-蒲公英云

object-c的protocol(协议）

在object-c中，协议的声明类似于类接口的声明，但是，协议没有父类，而且不能定义成员变量，只能定义成员函数，而且成员函数并不是在这个协议中实现，而是要在使用它的类中实现。
1. 使用说明：
（1）协议的声明方式,在.h中：
@protocol Myprotocol
-(void) myProtocolMethod;
@end
（2）协议的运用：
如果要使用一个协议，就要在声明类的时候，用<…>将协议名称列出，并且需要在这个类的实现中也必须同时实现协议中声明的成员函数。
例如，在你声明自己的类 MyClass的时候，可以这样做：
@interface MyClass: NSObject
而在实现的 MyClass.m中，就需要实现协议Myprotocol中声明的方法myProtocolMethod。
2. 例子代码：
//1. Printing.h
@protocol Printing
-(void) print;
@end

//2. Fraction.h
#import
#import “Printing.h”

@interface Fraction: NSObject {
int numerator;
int denominator;
}

-(Fraction*) initWithNumerator: (int) n denominator: (int) d;
-(void) setNumerator: (int) d;
-(void) setDenominator: (int) d;
-(void) setNumerator: (int) n andDenominator: (int) d;
-(int) numerator;
-(int) denominator;
@end

//3. Fraction.m
#import “Fraction.h”
#import

@implementation Fraction
-(Fraction*) initWithNumerator: (int) n denominator: (int) d {
self = [super init];

if ( self ) {
[self setNumerator: n andDenominator: d];
}

return self;
}

-(void) print {
printf( “%i/%i”, numerator, denominator );
}

-(void) setNumerator: (int) n {
numerator = n;
}

-(void) setDenominator: (int) d {
denominator = d;
}

-(void) setNumerator: (int) n andDenominator: (int) d {
numerator = n;
denominator = d;
}

-(int) denominator {
return denominator;
}

-(int) numerator {
return numerator;
}

-(Fraction*) copyWithZone: (NSZone*) zone {
return [[Fraction allocWithZone: zone] initWithNumerator: numerator
denominator: denominator];
}
@end

//4. Complex.h
#import
#import “Printing.h”

@interface Complex: NSObject {
double real;
double imaginary;
}

-(Complex*) initWithReal: (double) r andImaginary: (double) i;
-(void) setReal: (double) r;
-(void) setImaginary: (double) i;
-(void) setReal: (double) r andImaginary: (double) i;
-(double) real;
-(double) imaginary;
@end

//5. Complex.m
#import “Complex.h”
#import

@implementation Complex
-(Complex*) initWithReal: (double) r andImaginary: (double) i {
self = [super init];

if ( self ) {
[self setReal: r andImaginary: i];
}

return self;
}

-(void) setReal: (double) r {
real = r;
}

-(void) setImaginary: (double) i {
imaginary = i;
}

-(void) setReal: (double) r andImaginary: (double) i {
real = r;
imaginary = i;
}

-(double) real {
return real;
}

-(double) imaginary {
return imaginary;
}

-(void) print {
printf( “%_f + %_fi”, real, imaginary );
}
@end

//6. main.m
#import
#import “Fraction.h”
#import “Complex.h”

int main( int argc, const char *argv[] ) {
// create a new instance
Fraction *frac = [[Fraction alloc] initWithNumerator: 3 denominator: 10];
Complex *comp = [[Complex alloc] initWithReal: 5 andImaginary: 15];
id printable;
id copyPrintable;

// print it
printable = frac;
printf( “The fraction is: “ );
[printable print];
printf( “\n” );

// print complex
printable = comp;
printf( “The complex number is: “ );
[printable print];
printf( “\n” );

// this compiles because Fraction comforms to both Printing and NSCopyable
copyPrintable = frac;

// this doesn’t compile because Complex only conforms to Printing
//copyPrintable = comp;

// test conformance

// true
if ( [frac conformsToProtocol: @protocol( NSCopying )] == YES ) {
printf( “Fraction conforms to NSCopying\n” );
}

// false
if ( [comp conformsToProtocol: @protocol( NSCopying )] == YES ) {
printf( “Complex conforms to NSCopying\n” );
}

// free memory
[frac release];
[comp release];

return 0;
}

3. 编译运行：
gcc -fconstant-string-class=NSConstantString -c main.m -I /GNUstep/System/Library/Headers
gcc -c Complex.m -I /GNUstep/System/Library/Headers
gcc -c Fraction.m -I /GNUstep/System/Library/Headers
gcc main.o Complex.o Printing.o -o main -L /GNUstep/System/Library/Libraries/ -lobjc -lgnustep-base

$ ./main.exe
The fraction is: 3/10
The complex number is: _f + _fi
Fraction conforms to NSCopying

4. 说明：
（1）. protocol没有父类，或者说是无类的；
（2）. 如果一个类遵守了某个协议，那么这个类的子类也遵守该协议；

（3）. protocol只需要在.h中声明就可以，所以，协议也不需要编译成.o,也不可能编译成.o,因为没有.m文件。

（4） . 正如例子中呈现的一样，你的类中可以使用多个protocol，例如：

@interface SomeClass

…

@end