Objective-C代码学习大纲(4)

继承、多型(Inheritance, Polymorphism)以及其他物件导向功能

id 型别

Objective-C 有种叫做 id 的型别，它的运作有时候像是 void*，不过它却严格规定只能用在物件。Objective-C 与 Java 跟 C++ 不一样，你在唿叫一个物件的 method 时，并不需要知道这个物件的型别。当然这个 method 一定要存在，这称为 Objective-C 的讯息传递。

1. Fraction.h 
2.  
3. #import 
4.  
5. @interface Fraction: NSObject { 
6.  
7. int numerator; 
8.  
9. int denominator; 
10.  
11. } 
12.  
13. -(Fraction*) initWithNumerator: (int) n denominator: (int) d; 
14.  
15. -(void) print; 
16.  
17. -(void) setNumerator: (int) d; 
18.  
19. -(void) setDenominator: (int) d; 
20.  
21. -(void) setNumerator: (int) n andDenominator: (int) d; 
22.  
23. -(int) numerator; 
24.  
25. -(int) denominator; 
26.  
27. @end 
28.  
29. Fraction.m 
30.  
31. #import "Fraction.h" 
32.  
33. #import 
34.  
35. @implementation Fraction 
36.  
37. -(Fraction*) initWithNumerator: (int) n denominator: (int) d { 
38.  
39. self = [super init]; 
40.  
41. if ( self ) { 
42.  
43. [self setNumerator: n andDenominator: d]; 
44.  
45. } 
46.  
47. return self; 
48.  
49. } 
50.  
51. -(void) print { 
52.  
53. printf( "%i / %i", numerator, denominator ); 
54.  
55. } 
56.  
57. -(void) setNumerator: (int) n { 
58.  
59. nnumerator = n; 
60.  
61. } 
62.  
63. -(void) setDenominator: (int) d { 
64.  
65. ddenominator = d; 
66.  
67. } 
68.  
69. -(void) setNumerator: (int) n andDenominator: (int) d { 
70.  
71. nnumerator = n; 
72.  
73. ddenominator = d; 
74.  
75. } 
76.  
77. -(int) denominator { 
78.  
79. return denominator; 
80.  
81. } 
82.  
83. -(int) numerator { 
84.  
85. return numerator; 
86.  
87. } 
88.  
89. @end 
90.  
91. Complex.h 
92.  
93. #import 
94.  
95. @interface Complex: NSObject { 
96.  
97. double real; 
98.  
99. double imaginary; 
100.  
101. } 
102.  
103. -(Complex*) initWithReal: (double) r andImaginary: (double) i; 
104.  
105. -(void) setReal: (double) r; 
106.  
107. -(void) setImaginary: (double) i; 
108.  
109. -(void) setReal: (double) r andImaginary: (double) i; 
110.  
111. -(double) real; 
112.  
113. -(double) imaginary; 
114.  
115. -(void) print; 
116.  
117. @end 
118.  
119. Complex.m 
120.  
121. #import "Complex.h" 
122.  
123. #import 
124.  
125. @implementation Complex 
126.  
127. -(Complex*) initWithReal: (double) r andImaginary: (double) i { 
128.  
129. self = [super init]; 
130.  
131. if ( self ) { 
132.  
133. [self setReal: r andImaginary: i]; 
134.  
135. } 
136.  
137. return self; 
138.  
139. } 
140.  
141. -(void) setReal: (double) r { 
142.  
143. rreal = r; 
144.  
145. } 
146.  
147. -(void) setImaginary: (double) i { 
148.  
149. iimaginary = i; 
150.  
151. } 
152.  
153. -(void) setReal: (double) r andImaginary: (double) i { 
154.  
155. rreal = r; 
156.  
157. iimaginary = i; 
158.  
159. } 
160.  
161. -(double) real { 
162.  
163. return real; 
164.  
165. } 
166.  
167. -(double) imaginary { 
168.  
169. return imaginary; 
170.  
171. } 
172.  
173. -(void) print { 
174.  
175. printf( "%_f + %_fi", real, imaginary ); 
176.  
177. } 
178.  
179. @end 
180.  
181. main.m 
182.  
183. #import 
184.  
185. #import "Fraction.h" 
186.  
187. #import "Complex.h" 
188.  
189. int main( int argc, const char *argv[] ) { 
190.  
191. // create a new instance 
192.  
193. Fraction *frac = [[Fraction alloc] initWithNumerator: 1 denominator: 10]; 
194.  
195. Complex *comp = [[Complex alloc] initWithReal: 10 andImaginary: 15]; 
196.  
197. id number; 
198.  
199. // print fraction 
200.  
201. number = frac; 
202.  
203. printf( "The fraction is: " ); 
204.  
205. [number print]; 
206.  
207. printf( "\n" ); 
208.  
209. // print complex 
210.  
211. number = comp; 
212.  
213. printf( "The complex number is: " ); 
214.  
215. [number print]; 
216.  
217. printf( "\n" ); 
218.  
219. // free memory 
220.  
221. [frac release]; 
222.  
223. [comp release]; 
224.  
225. return 0; 
226.  
227. } 

output

1. The fraction is: 1 / 10 
2.  
3. The complex number is: 10.000000 + 15.000000i 

这种动态连结有显而易见的好处。你不需要知道你唿叫 method 的那个东西是什么型别，如果这个物件对这个讯息有反应，那就会唤起这个 method。这也不会牵涉到一堆繁琐的转型动作，比如在 Java 裡唿叫一个整数物件的 .intValue() 就得先转型，然后才能唿叫这个 method。

继承(Inheritance)

1. Rectangle.h 
2.  
3. #import 
4.  
5. @interface Rectangle: NSObject { 
6.  
7. int width; 
8.  
9. int height; 
10.  
11. } 
12.  
13. -(Rectangle*) initWithWidth: (int) w height: (int) h; 
14.  
15. -(void) setWidth: (int) w; 
16.  
17. -(void) setHeight: (int) h; 
18.  
19. -(void) setWidth: (int) w height: (int) h; 
20.  
21. -(int) width; 
22.  
23. -(int) height; 
24.  
25. -(void) print; 
26.  
27. @end 
28.  
29. Rectangle.m 
30.  
31. #import "Rectangle.h" 
32.  
33. #import 
34.  
35. @implementation Rectangle 
36.  
37. -(Rectangle*) initWithWidth: (int) w height: (int) h { 
38.  
39. self = [super init]; 
40.  
41. if ( self ) { 
42.  
43. [self setWidth: w height: h]; 
44.  
45. } 
46.  
47. return self; 
48.  
49. } 
50.  
51. -(void) setWidth: (int) w { 
52.  
53. wwidth = w; 
54.  
55. } 
56.  
57. -(void) setHeight: (int) h { 
58.  
59. hheight = h; 
60.  
61. } 
62.  
63. -(void) setWidth: (int) w height: (int) h { 
64.  
65. wwidth = w; 
66.  
67. hheight = h; 
68.  
69. } 
70.  
71. -(int) width { 
72.  
73. return width; 
74.  
75. } 
76.  
77. -(int) height { 
78.  
79. return height; 
80.  
81. } 
82.  
83. -(void) print { 
84.  
85. printf( "width = %i, height = %i", width, height ); 
86.  
87. } 
88.  
89. @end 
90.  
91. Square.h 
92.  
93. #import "Rectangle.h" 
94.  
95. @interface Square: Rectangle 
96.  
97. -(Square*) initWithSize: (int) s; 
98.  
99. -(void) setSize: (int) s; 
100.  
101. -(int) size; 
102.  
103. @end 
104.  
105. Square.m 
106.  
107. #import "Square.h" 
108.  
109. @implementation Square 
110.  
111. -(Square*) initWithSize: (int) s { 
112.  
113. self = [super init]; 
114.  
115. if ( self ) { 
116.  
117. [self setSize: s]; 
118.  
119. } 
120.  
121. return self; 
122.  
123. } 
124.  
125. -(void) setSize: (int) s { 
126.  
127. width = s; 
128.  
129. height = s; 
130.  
131. } 
132.  
133. -(int) size { 
134.  
135. return width; 
136.  
137. } 
138.  
139. -(void) setWidth: (int) w { 
140.  
141. [self setSize: w]; 
142.  
143. } 
144.  
145. -(void) setHeight: (int) h { 
146.  
147. [self setSize: h]; 
148.  
149. } 
150.  
151. @end 
152.  
153. main.m 
154.  
155. #import "Square.h" 
156.  
157. #import "Rectangle.h" 
158.  
159. #import 
160.  
161. int main( int argc, const char *argv[] ) { 
162.  
163. Rectangle *rec = [[Rectangle alloc] initWithWidth: 10 height: 20]; 
164.  
165. Square *sq = [[Square alloc] initWithSize: 15]; 
166.  
167. // print em 
168.  
169. printf( "Rectangle: " ); 
170.  
171. [rec print]; 
172.  
173. printf( "\n" ); 
174.  
175. printf( "Square: " ); 
176.  
177. [sq print]; 
178.  
179. printf( "\n" ); 
180.  
181. // update square 
182.  
183. [sq setWidth: 20]; 
184.  
185. printf( "Square after change: " ); 
186.  
187. [sq print]; 
188.  
189. printf( "\n" ); 
190.  
191. // free memory 
192.  
193. [rec release]; 
194.  
195. [sq release]; 
196.  
197. return 0; 
198.  
199. } 

output

1. Rectangle: width = 10, height = 20 
2.  
3. Square: width = 15, height = 15 
4.  
5. Square after change: width = 20, height = 20 

继承在 Objective-C 裡比较像 Java。当你扩充你的 super class(所以只能有一个 parent)，你想自订这个 super class 的 method，只要简单的在你的 child class implementation 裡放上新的实作内容即可。而不需要 C++ 裡呆呆的 virtual table。

这裡还有一个值得玩味的地方，如果你企图像这样去唿叫 rectangle 的 constructor： Square *sq = [[Square alloc] initWithWidth: 10 height: 15]，会发生什么事?答案是会产生一个编译器错误。因为 rectangle constructor 回传的型别是 Rectangle*，而不是 Square*，所以这行不通。在某种情况下如果你真想这样用，使用 id 型别会是很好的选择。如果你想使用 parent 的 constructor，只要把 Rectangle* 回传型别改成 id 即可。

动态识别(Dynamic types)

这裡有一些用于 Objective-C 动态识别的 methods(说明部分採中英并列，因为我觉得英文比较传神，中文怎么译都怪)：

1. -(BOOL) isKindOfClass: classObjis object a descendent or member of classObj 

此物件是否是 classObj 的子孙或一员

1. -(BOOL) isMemberOfClass: classObjis object a member of classObj 

此物件是否是 classObj 的一员

1. -(BOOL) respondsToSelector: selectordoes the object have a method named specifiec by the selector 

此物件是否有叫做 selector 的 method

1. +(BOOL) instancesRespondToSelector: selectordoes an object created by this class have the ability to respond to the specified selector 

此物件是否是由有能力回应指定 selector 的物件所产生

1. -(id) performSelector: selectorinvoke the specified selector on the object 

唤起此物件的指定 selector

所有继承自 NSObject 都有一个可回传一个 class 物件的 class method。这非常近似于 Java 的 getClass() method。这个 class 物件被使用于前述的 methods 中。

Selectors 在 Objective-C 用以表示讯息。下一个範例会秀出建立 selector 的语法。

1. main.m 
2.  
3. #import "Square.h" 
4.  
5. #import "Rectangle.h" 
6.  
7. #import 
8.  
9. int main( int argc, const char *argv[] ) { 
10.  
11. Rectangle *rec = [[Rectangle alloc] initWithWidth: 10 height: 20]; 
12.  
13. Square *sq = [[Square alloc] initWithSize: 15]; 
14.  
15. // isMemberOfClass 
16.  
17. // true 
18.  
19. if ( [sq isMemberOfClass: [Square class]] == YES ) { 
20.  
21. printf( "square is a member of square class\n" ); 
22.  
23. } 
24.  
25. // false 
26.  
27. if ( [sq isMemberOfClass: [Rectangle class]] == YES ) { 
28.  
29. printf( "square is a member of rectangle class\n" ); 
30.  
31. } 
32.  
33. // false 
34.  
35. if ( [sq isMemberOfClass: [NSObject class]] == YES ) { 
36.  
37. printf( "square is a member of object class\n" ); 
38.  
39. } 
40.  
41. // isKindOfClass 
42.  
43. // true 
44.  
45. if ( [sq isKindOfClass: [Square class]] == YES ) { 
46.  
47. printf( "square is a kind of square class\n" ); 
48.  
49. } 
50.  
51. // true 
52.  
53. if ( [sq isKindOfClass: [Rectangle class]] == YES ) { 
54.  
55. printf( "square is a kind of rectangle class\n" ); 
56.  
57. } 
58.  
59. // true 
60.  
61. if ( [sq isKindOfClass: [NSObject class]] == YES ) { 
62.  
63. printf( "square is a kind of object class\n" ); 
64.  
65. } 
66.  
67. // respondsToSelector 
68.  
69. // true 
70.  
71. if ( [sq respondsToSelector: @selector( setSize: )] == YES ) { 
72.  
73. printf( "square responds to setSize: method\n" ); 
74.  
75. } 
76.  
77. // false 
78.  
79. if ( [sq respondsToSelector: @selector( nonExistant )] == YES ) { 
80.  
81. printf( "square responds to nonExistant method\n" ); 
82.  
83. } 
84.  
85. // true 
86.  
87. if ( [Square respondsToSelector: @selector( alloc )] == YES ) { 
88.  
89. printf( "square class responds to alloc method\n" ); 
90.  
91. } 
92.  
93. // instancesRespondToSelector 
94.  
95. // false 
96.  
97. if ( [Rectangle instancesRespondToSelector: @selector( setSize: )] == YES ) { 
98.  
99. printf( "rectangle instance responds to setSize: method\n" ); 
100.  
101. } 
102.  
103. // true 
104.  
105. if ( [Square instancesRespondToSelector: @selector( setSize: )] == YES ) { 
106.  
107. printf( "square instance responds to setSize: method\n" ); 
108.  
109. } 
110.  
111. // free memory 
112.  
113. [rec release]; 
114.  
115. [sq release]; 
116.  
117. return 0; 
118.  
119. } 

output

1. square is a member of square class 
2.  
3. square is a kind of square class 
4.  
5. square is a kind of rectangle class 
6.  
7. square is a kind of object class 
8.  
9. square responds to setSize: method 
10.  
11. square class responds to alloc method 
12.  
13. square instance responds to setSize: method 
14.  
15. Categories 

当你想要为某个 class 新增 methods，你通常会扩充(extend，即继承)它。然而这不一定是个完美解法，特别是你想要重写一个 class 的某个功能，但你却没有塬始码时。Categories 允许你在现有的 class 加入新功能，但不需要扩充它。Ruby 语言也有类似的功能。

1. FractionMath.h 
2.  
3. #import "Fraction.h" 
4.  
5. @interface Fraction (Math) 
6.  
7. -(Fraction*) add: (Fraction*) f; 
8.  
9. -(Fraction*) mul: (Fraction*) f; 
10.  
11. -(Fraction*) div: (Fraction*) f; 
12.  
13. -(Fraction*) sub: (Fraction*) f; 
14.  
15. @end 
16.  
17. FractionMath.m 
18.  
19. #import "FractionMath.h" 
20.  
21. @implementation Fraction (Math) 
22.  
23. -(Fraction*) add: (Fraction*) f { 
24.  
25. return [[Fraction alloc] initWithNumerator: numerator * [f denominator] + 
26.  
27. denominator * [f numerator] 
28.  
29. denominator: denominator * [f denominator]]; 
30.  
31. } 
32.  
33. -(Fraction*) mul: (Fraction*) f { 
34.  
35. return [[Fraction alloc] initWithNumerator: numerator * [f numerator] 
36.  
37. denominator: denominator * [f denominator]]; 
38.  
39. } 
40.  
41. -(Fraction*) div: (Fraction*) f { 
42.  
43. return [[Fraction alloc] initWithNumerator: numerator * [f denominator] 
44.  
45. denominator: denominator * [f numerator]]; 
46.  
47. } 
48.  
49. -(Fraction*) sub: (Fraction*) f { 
50.  
51. return [[Fraction alloc] initWithNumerator: numerator * [f denominator] - 
52.  
53. denominator * [f numerator] 
54.  
55. denominator: denominator * [f denominator]]; 
56.  
57. } 
58.  
59. @end 
60.  
61. main.m 
62.  
63. #import 
64.  
65. #import "Fraction.h" 
66.  
67. #import "FractionMath.h" 
68.  
69. int main( int argc, const char *argv[] ) { 
70.  
71. // create a new instance 
72.  
73. Fraction *frac1 = [[Fraction alloc] initWithNumerator: 1 denominator: 3]; 
74.  
75. Fraction *frac2 = [[Fraction alloc] initWithNumerator: 2 denominator: 5]; 
76.  
77. Fraction *frac3 = [frac1 mul: frac2]; 
78.  
79. // print it 
80.  
81. [frac1 print]; 
82.  
83. printf( " * " ); 
84.  
85. [frac2 print]; 
86.  
87. printf( " = " ); 
88.  
89. [frac3 print]; 
90.  
91. printf( "\n" ); 
92.  
93. // free memory 
94.  
95. [frac1 release]; 
96.  
97. [frac2 release]; 
98.  
99. [frac3 release]; 
100.  
101. return 0; 
102.  
103. } 

output

1. 1/3 * 2/5 = 2/15 

重点是 @implementation 跟 @interface 这两行：@interface Fraction (Math) 以及 @implementation Fraction (Math).

(同一个 class)只能有一个同名的 category，其他的 categories 得加上不同的、独一无二的名字。

Categories 在建立 private methods 时十分有用。因为 Objective-C 并没有像 Java 这种 private/protected/public methods 的概念，所以必须要使用 categories 来达成这种功能。作法是把 private method 从你的 class header (.h) 档案移到 implementation (.m) 档案。以下是此种作法一个简短的範例。

1. MyClass.h 
2.  
3. #import 
4.  
5. @interface MyClass: NSObject 
6.  
7. -(void) publicMethod; 
8.  
9. @end 
10.  
11. MyClass.m 
12.  
13. #import "MyClass.h" 
14.  
15. #import 
16.  
17. @implementation MyClass 
18.  
19. -(void) publicMethod { 
20.  
21. printf( "public method\n" ); 
22.  
23. } 
24.  
25. @end 
26.  
27. // private methods 
28.  
29. @interface MyClass (Private) 
30.  
31. -(void) privateMethod; 
32.  
33. @end 
34.  
35. @implementation MyClass (Private) 
36.  
37. -(void) privateMethod { 
38.  
39. printf( "private method\n" ); 
40.  
41. } 
42.  
43. @end 
44.  
45. main.m 
46.  
47. #import "MyClass.h" 
48.  
49. int main( int argc, const char *argv[] ) { 
50.  
51. MyClass *obj = [[MyClass alloc] init]; 
52.  
53. // this compiles 
54.  
55. [obj publicMethod]; 
56.  
57. // this throws errors when compiling 
58.  
59. //[obj privateMethod]; 
60.  
61. // free memory 
62.  
63. [obj release]; 
64.  
65. return 0; 
66.  
67. } 

output

1. public method 
2.  
3. Posing 

Posing 有点像 categories，但是不太一样。它允许你扩充一个 class，并且全面性地的扮演(pose)这个 super class。例如：你有一个扩充 NSArray 的 NSArrayChild 物件。如果你让 NSArrayChild 扮演 NSArray，则在你的程式码中所有的 NSArray 都会自动被替代为 NSArrayChild。

1. FractionB.h 
2.  
3. #import "Fraction.h" 
4.  
5. @interface FractionB: Fraction 
6.  
7. -(void) print; 
8.  
9. @end 
10.  
11. FractionB.m 
12.  
13. #import "FractionB.h" 
14.  
15. #import 
16.  
17. @implementation FractionB 
18.  
19. -(void) print { 
20.  
21. printf( "(%i/%i)", numerator, denominator ); 
22.  
23. } 
24.  
25. @end 
26.  
27. main.m 
28.  
29. #import 
30.  
31. #import "Fraction.h" 
32.  
33. #import "FractionB.h" 
34.  
35. int main( int argc, const char *argv[] ) { 
36.  
37. Fraction *frac = [[Fraction alloc] initWithNumerator: 3 denominator: 10]; 
38.  
39. // print it 
40.  
41. printf( "The fraction is: " ); 
42.  
43. [frac print]; 
44.  
45. printf( "\n" ); 
46.  
47. // make FractionB pose as Fraction 
48.  
49. [FractionB poseAsClass: [Fraction class]]; 
50.  
51. Fraction *frac2 = [[Fraction alloc] initWithNumerator: 3 denominator: 10]; 
52.  
53. // print it 
54.  
55. printf( "The fraction is: " ); 
56.  
57. [frac2 print]; 
58.  
59. printf( "\n" ); 
60.  
61. // free memory 
62.  
63. [frac release]; 
64.  
65. [frac2 release]; 
66.  
67. return 0; 
68.  
69. } 

output

1. The fraction is: 3/10 
2.  
3. The fraction is: (3/10) 

这个程式的输出中，第一个 fraction 会输出 3/10，而第二个会输出 (3/10)。这是 FractionB 中实作的方式。

poseAsClass 这个 method 是 NSObject 的一部份，它允许 subclass 扮演 superclass。

Protocols

Objective-C 裡的 Protocol 与 Java 的 interface 或是 C++ 的 purely virtual class 相同。

1. Printing.h 
2.  
3. @protocol Printing 
4.  
5. -(void) print; 
6.  
7. @end 
8.  
9. Fraction.h 
10.  
11. #import 
12.  
13. #import "Printing.h" 
14.  
15. @interface Fraction: NSObject { 
16.  
17. int numerator; 
18.  
19. int denominator; 
20.  
21. } 
22.  
23. -(Fraction*) initWithNumerator: (int) n denominator: (int) d; 
24.  
25. -(void) setNumerator: (int) d; 
26.  
27. -(void) setDenominator: (int) d; 
28.  
29. -(void) setNumerator: (int) n andDenominator: (int) d; 
30.  
31. -(int) numerator; 
32.  
33. -(int) denominator; 
34.  
35. @end 
36.  
37. Fraction.m 
38.  
39. #import "Fraction.h" 
40.  
41. #import 
42.  
43. @implementation Fraction 
44.  
45. -(Fraction*) initWithNumerator: (int) n denominator: (int) d { 
46.  
47. self = [super init]; 
48.  
49. if ( self ) { 
50.  
51. [self setNumerator: n andDenominator: d]; 
52.  
53. } 
54.  
55. return self; 
56.  
57. } 
58.  
59. -(void) print { 
60.  
61. printf( "%i/%i", numerator, denominator ); 
62.  
63. } 
64.  
65. -(void) setNumerator: (int) n { 
66.  
67. nnumerator = n; 
68.  
69. } 
70.  
71. -(void) setDenominator: (int) d { 
72.  
73. ddenominator = d; 
74.  
75. } 
76.  
77. -(void) setNumerator: (int) n andDenominator: (int) d { 
78.  
79. nnumerator = n; 
80.  
81. ddenominator = d; 
82.  
83. } 
84.  
85. -(int) denominator { 
86.  
87. return denominator; 
88.  
89. } 
90.  
91. -(int) numerator { 
92.  
93. return numerator; 
94.  
95. } 
96.  
97. -(Fraction*) copyWithZone: (NSZone*) zone { 
98.  
99. return [[Fraction allocWithZone: zone] initWithNumerator: numerator 
100.  
101. denominator: denominator]; 
102.  
103. } 
104.  
105. @end 
106.  
107. Complex.h 
108.  
109. #import 
110.  
111. #import "Printing.h" 
112.  
113. @interface Complex: NSObject { 
114.  
115. double real; 
116.  
117. double imaginary; 
118.  
119. } 
120.  
121. -(Complex*) initWithReal: (double) r andImaginary: (double) i; 
122.  
123. -(void) setReal: (double) r; 
124.  
125. -(void) setImaginary: (double) i; 
126.  
127. -(void) setReal: (double) r andImaginary: (double) i; 
128.  
129. -(double) real; 
130.  
131. -(double) imaginary; 
132.  
133. @end 
134.  
135. Complex.m 
136.  
137. #import "Complex.h" 
138.  
139. #import 
140.  
141. @implementation Complex 
142.  
143. -(Complex*) initWithReal: (double) r andImaginary: (double) i { 
144.  
145. self = [super init]; 
146.  
147. if ( self ) { 
148.  
149. [self setReal: r andImaginary: i]; 
150.  
151. } 
152.  
153. return self; 
154.  
155. } 
156.  
157. -(void) setReal: (double) r { 
158.  
159. rreal = r; 
160.  
161. } 
162.  
163. -(void) setImaginary: (double) i { 
164.  
165. iimaginary = i; 
166.  
167. } 
168.  
169. -(void) setReal: (double) r andImaginary: (double) i { 
170.  
171. rreal = r; 
172.  
173. iimaginary = i; 
174.  
175. } 
176.  
177. -(double) real { 
178.  
179. return real; 
180.  
181. } 
182.  
183. -(double) imaginary { 
184.  
185. return imaginary; 
186.  
187. } 
188.  
189. -(void) print { 
190.  
191. printf( "%_f + %_fi", real, imaginary ); 
192.  
193. } 
194.  
195. @end 
196.  
197. main.m 
198.  
199. #import 
200.  
201. #import "Fraction.h" 
202.  
203. #import "Complex.h" 
204.  
205. int main( int argc, const char *argv[] ) { 
206.  
207. // create a new instance 
208.  
209. Fraction *frac = [[Fraction alloc] initWithNumerator: 3 denominator: 10]; 
210.  
211. Complex *comp = [[Complex alloc] initWithReal: 5 andImaginary: 15]; 
212.  
213. id printable; 
214.  
215. id copyPrintable; 
216.  
217. // print it 
218.  
219. printable = frac; 
220.  
221. printf( "The fraction is: " ); 
222.  
223. [printable print]; 
224.  
225. printf( "\n" ); 
226.  
227. // print complex 
228.  
229. printable = comp; 
230.  
231. printf( "The complex number is: " ); 
232.  
233. [printable print]; 
234.  
235. printf( "\n" ); 
236.  
237. // this compiles because Fraction comforms to both Printing and NSCopyable 
238.  
239. copyPrintable = frac; 
240.  
241. // this doesn‘t compile because Complex only conforms to Printing 
242.  
243. //copyPrintable = comp; 
244.  
245. // test conformance 
246.  
247. // true 
248.  
249. if ( [frac conformsToProtocol: @protocol( NSCopying )] == YES ) { 
250.  
251. printf( "Fraction conforms to NSCopying\n" ); 
252.  
253. } 
254.  
255. // false 
256.  
257. if ( [comp conformsToProtocol: @protocol( NSCopying )] == YES ) { 
258.  
259. printf( "Complex conforms to NSCopying\n" ); 
260.  
261. } 
262.  
263. // free memory 
264.  
265. [frac release]; 
266.  
267. [comp release]; 
268.  
269. return 0; 
270.  
271. } 

output

1. The fraction is: 3/10 
2.  
3. The complex number is: 5.000000 + 15.000000i 
4.  
5. Fraction conforms to NSCopying 

protocol 的宣告十分简单，基本上就是 @protocol ProtocolName (methods you must implement) @end。

要遵从(conform)某个 protocol，将要遵从的 protocols 放在 <> 裡面，并以逗点分隔。如：@interface SomeClass

protocol 要求实作的 methods 不需要放在 header 档裡面的 methods 列表中。如你所见，Complex.h 档案裡没有 -(void) print 的宣告，却还是要实作它，因为它(Complex class)遵从了这个 protocol。

Objective-C 的介面系统有一个独一无二的观念是如何指定一个型别。比起 C++ 或 Java 的指定方式，如：Printing *someVar = ( Printing * ) frac; 你可以使用 id 型别加上 protocol：id var = frac;。这让你可以动态地指定一个要求多个 protocol 的型别，却从头到尾只用了一个变数。如： var = frac;

就像使用@selector 来测试物件的继承关係，你可以使用 @protocol 来测试物件是否遵从介面。如果物件遵从这个介面，[object conformsToProtocol: @protocol( SomeProtocol )] 会回传一个 YES 型态的 BOOL 物件。同样地，对 class 而言也能如法炮製 [SomeClass conformsToProtocol: @protocol( SomeProtocol )]。