object-c的protocol(协议）

不念不忘少年蓝@ 2023-10-18 22:29 35阅读 0赞

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

...

@end