object-c的protocol(协议）

在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