Objective-C学习大纲 二

本文为台湾出版的《Objective-C学习大纲》的翻译文档，系统介绍了Objective-C代码，很多名词为台湾同胞特指词汇，在学习时仔细研读才能体会。

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

id 型别

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

1. Fraction.h
3. #import
5. @interfaceFraction:NSObject{
7. intnumerator;
9. intdenominator;
11. }
13. -(Fraction*)initWithNumerator:(int)ndenominator:(int)d;
15. -(void)print;
17. -(void)setNumerator:(int)d;
19. -(void)setDenominator:(int)d;
21. -(void)setNumerator:(int)nandDenominator:(int)d;
23. -(int)numerator;
25. -(int)denominator;
27. @end
29. Fraction.m
31. #import"Fraction.h"
33. #import
35. @implementationFraction
37. -(Fraction*)initWithNumerator:(int)ndenominator:(int)d{
39. self=[superinit];
41. if(self){
43. [selfsetNumerator:nandDenominator:d];
45. }
47. returnself;
49. }
51. -(void)print{
53. printf("%i/%i",numerator,denominator);
55. }
57. -(void)setNumerator:(int)n{
59. nnumerator=n;
61. }
63. -(void)setDenominator:(int)d{
65. ddenominator=d;
67. }
69. -(void)setNumerator:(int)nandDenominator:(int)d{
71. nnumerator=n;
73. ddenominator=d;
75. }
77. -(int)denominator{
79. returndenominator;
81. }
83. -(int)numerator{
85. returnnumerator;
87. }
89. @end
91. Complex.h
93. #import
95. @interfaceComplex:NSObject{
97. doublereal;
99. doubleimaginary;
101. }
103. -(Complex*)initWithReal:(double)randImaginary:(double)i;
105. -(void)setReal:(double)r;
107. -(void)setImaginary:(double)i;
109. -(void)setReal:(double)randImaginary:(double)i;
111. -(double)real;
113. -(double)imaginary;
115. -(void)print;
117. @end
119. Complex.m
121. #import"Complex.h"
123. #import
125. @implementationComplex
127. -(Complex*)initWithReal:(double)randImaginary:(double)i{
129. self=[superinit];
131. if(self){
133. [selfsetReal:randImaginary:i];
135. }
137. returnself;
139. }
141. -(void)setReal:(double)r{
143. rreal=r;
145. }
147. -(void)setImaginary:(double)i{
149. iimaginary=i;
151. }
153. -(void)setReal:(double)randImaginary:(double)i{
155. rreal=r;
157. iimaginary=i;
159. }
161. -(double)real{
163. returnreal;
165. }
167. -(double)imaginary{
169. returnimaginary;
171. }
173. -(void)print{
175. printf("%_f+%_fi",real,imaginary);
177. }
179. @end
181. main.m
183. #import
185. #import"Fraction.h"
187. #import"Complex.h"
189. intmain(intargc,constchar*argv[]){
191. //createanewinstance
193. Fraction*frac=[[Fractionalloc]initWithNumerator:1denominator:10];
195. Complex*comp=[[Complexalloc]initWithReal:10andImaginary:15];
197. idnumber;
199. //printfraction
201. number=frac;
203. printf("Thefractionis:");
205. [numberprint];
207. printf("\n");
209. //printcomplex
211. number=comp;
213. printf("Thecomplexnumberis:");
215. [numberprint];
217. printf("\n");
219. //freememory
221. [fracrelease];
223. [comprelease];
225. return0;
227. }

output

1. Thefractionis:1/10
3. Thecomplexnumberis:10.000000+15.000000i

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

继承(Inheritance)

1. Rectangle.h
3. #import
5. @interfaceRectangle:NSObject{
7. intwidth;
9. intheight;
11. }
13. -(Rectangle*)initWithWidth:(int)wheight:(int)h;
15. -(void)setWidth:(int)w;
17. -(void)setHeight:(int)h;
19. -(void)setWidth:(int)wheight:(int)h;
21. -(int)width;
23. -(int)height;
25. -(void)print;
27. @end
29. Rectangle.m
31. #import"Rectangle.h"
33. #import
35. @implementationRectangle
37. -(Rectangle*)initWithWidth:(int)wheight:(int)h{
39. self=[superinit];
41. if(self){
43. [selfsetWidth:wheight:h];
45. }
47. returnself;
49. }
51. -(void)setWidth:(int)w{
53. wwidth=w;
55. }
57. -(void)setHeight:(int)h{
59. hheight=h;
61. }
63. -(void)setWidth:(int)wheight:(int)h{
65. wwidth=w;
67. hheight=h;
69. }
71. -(int)width{
73. returnwidth;
75. }
77. -(int)height{
79. returnheight;
81. }
83. -(void)print{
85. printf("width=%i,height=%i",width,height);
87. }
89. @end
91. Square.h
93. #import"Rectangle.h"
95. @interfaceSquare:Rectangle
97. -(Square*)initWithSize:(int)s;
99. -(void)setSize:(int)s;
101. -(int)size;
103. @end
105. Square.m
107. #import"Square.h"
109. @implementationSquare
111. -(Square*)initWithSize:(int)s{
113. self=[superinit];
115. if(self){
117. [selfsetSize:s];
119. }
121. returnself;
123. }
125. -(void)setSize:(int)s{
127. width=s;
129. height=s;
131. }
133. -(int)size{
135. returnwidth;
137. }
139. -(void)setWidth:(int)w{
141. [selfsetSize:w];
143. }
145. -(void)setHeight:(int)h{
147. [selfsetSize:h];
149. }
151. @end
153. main.m
155. #import"Square.h"
157. #import"Rectangle.h"
159. #import
161. intmain(intargc,constchar*argv[]){
163. Rectangle*rec=[[Rectanglealloc]initWithWidth:10height:20];
165. Square*sq=[[Squarealloc]initWithSize:15];
167. //printem
169. printf("Rectangle:");
171. [recprint];
173. printf("\n");
175. printf("Square:");
177. [sqprint];
179. printf("\n");
181. //updatesquare
183. [sqsetWidth:20];
185. printf("Squareafterchange:");
187. [sqprint];
189. printf("\n");
191. //freememory
193. [recrelease];
195. [sqrelease];
197. return0;
199. }

output

1. Rectangle:width=10,height=20
3. Square:width=15,height=15
5. Squareafterchange: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:classObjisobjectadescendentormemberofclassObj

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

1. -(BOOL)isMemberOfClass:classObjisobjectamemberofclassObj

此物件是否是 classObj 的一员

1. -(BOOL)respondsToSelector:selectordoestheobjecthaveamethodnamedspecifiecbytheselector

此物件是否有叫做 selector 的 method

1. +(BOOL)instancesRespondToSelector:selectordoesanobjectcreatedbythisclasshavetheabilitytorespondtothespecifiedselector

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

1. -(id)performSelector:selectorinvokethespecifiedselectorontheobject

唤起此物件的指定 selector

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

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

1. main.m
3. #import"Square.h"
5. #import"Rectangle.h"
7. #import
9. intmain(intargc,constchar*argv[]){
11. Rectangle*rec=[[Rectanglealloc]initWithWidth:10height:20];
13. Square*sq=[[Squarealloc]initWithSize:15];
15. //isMemberOfClass
17. //true
19. if([sqisMemberOfClass:[Squareclass]]==YES){
21. printf("squareisamemberofsquareclass\n");
23. }
25. //false
27. if([sqisMemberOfClass:[Rectangleclass]]==YES){
29. printf("squareisamemberofrectangleclass\n");
31. }
33. //false
35. if([sqisMemberOfClass:[NSObjectclass]]==YES){
37. printf("squareisamemberofobjectclass\n");
39. }
41. //isKindOfClass
43. //true
45. if([sqisKindOfClass:[Squareclass]]==YES){
47. printf("squareisakindofsquareclass\n");
49. }
51. //true
53. if([sqisKindOfClass:[Rectangleclass]]==YES){
55. printf("squareisakindofrectangleclass\n");
57. }
59. //true
61. if([sqisKindOfClass:[NSObjectclass]]==YES){
63. printf("squareisakindofobjectclass\n");
65. }
67. //respondsToSelector
69. //true
71. if([sqrespondsToSelector:@selector(setSize:)]==YES){
73. printf("squarerespondstosetSize:method\n");
75. }
77. //false
79. if([sqrespondsToSelector:@selector(nonExistant)]==YES){
81. printf("squarerespondstononExistantmethod\n");
83. }
85. //true
87. if([SquarerespondsToSelector:@selector(alloc)]==YES){
89. printf("squareclassrespondstoallocmethod\n");
91. }
93. //instancesRespondToSelector
95. //false
97. if([RectangleinstancesRespondToSelector:@selector(setSize:)]==YES){
99. printf("rectangleinstancerespondstosetSize:method\n");
101. }
103. //true
105. if([SquareinstancesRespondToSelector:@selector(setSize:)]==YES){
107. printf("squareinstancerespondstosetSize:method\n");
109. }
111. //freememory
113. [recrelease];
115. [sqrelease];
117. return0;
119. }

output

1. squareisamemberofsquareclass
3. squareisakindofsquareclass
5. squareisakindofrectangleclass
7. squareisakindofobjectclass
9. squarerespondstosetSize:method
11. squareclassrespondstoallocmethod
13. squareinstancerespondstosetSize:method
15. Categories

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

1. FractionMath.h
3. #import"Fraction.h"
5. @interfaceFraction(Math)
7. -(Fraction*)add:(Fraction*)f;
9. -(Fraction*)mul:(Fraction*)f;
11. -(Fraction*)div:(Fraction*)f;
13. -(Fraction*)sub:(Fraction*)f;
15. @end
17. FractionMath.m
19. #import"FractionMath.h"
21. @implementationFraction(Math)
23. -(Fraction*)add:(Fraction*)f{
25. return[[Fractionalloc]initWithNumerator:numerator*[fdenominator]+
27. denominator*[fnumerator]
29. denominator:denominator*[fdenominator]];
31. }
33. -(Fraction*)mul:(Fraction*)f{
35. return[[Fractionalloc]initWithNumerator:numerator*[fnumerator]
37. denominator:denominator*[fdenominator]];
39. }
41. -(Fraction*)div:(Fraction*)f{
43. return[[Fractionalloc]initWithNumerator:numerator*[fdenominator]
45. denominator:denominator*[fnumerator]];
47. }
49. -(Fraction*)sub:(Fraction*)f{
51. return[[Fractionalloc]initWithNumerator:numerator*[fdenominator]-
53. denominator*[fnumerator]
55. denominator:denominator*[fdenominator]];
57. }
59. @end
61. main.m
63. #import
65. #import"Fraction.h"
67. #import"FractionMath.h"
69. intmain(intargc,constchar*argv[]){
71. //createanewinstance
73. Fraction*frac1=[[Fractionalloc]initWithNumerator:1denominator:3];
75. Fraction*frac2=[[Fractionalloc]initWithNumerator:2denominator:5];
77. Fraction*frac3=[frac1mul:frac2];
79. //printit
81. [frac1print];
83. printf("*");
85. [frac2print];
87. printf("=");
89. [frac3print];
91. printf("\n");
93. //freememory
95. [frac1release];
97. [frac2release];
99. [frac3release];
101. return0;
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
3. #import
5. @interfaceMyClass:NSObject
7. -(void)publicMethod;
9. @end
11. MyClass.m
13. #import"MyClass.h"
15. #import
17. @implementationMyClass
19. -(void)publicMethod{
21. printf("publicmethod\n");
23. }
25. @end
27. //privatemethods
29. @interfaceMyClass(Private)
31. -(void)privateMethod;
33. @end
35. @implementationMyClass(Private)
37. -(void)privateMethod{
39. printf("privatemethod\n");
41. }
43. @end
45. main.m
47. #import"MyClass.h"
49. intmain(intargc,constchar*argv[]){
51. MyClass*obj=[[MyClassalloc]init];
53. //thiscompiles
55. [objpublicMethod];
57. //thisthrowserrorswhencompiling
59. //[objprivateMethod];
61. //freememory
63. [objrelease];
65. return0;
67. }

output

1. publicmethod
3. Posing

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

1. FractionB.h
3. #import"Fraction.h"
5. @interfaceFractionB:Fraction
7. -(void)print;
9. @end
11. FractionB.m
13. #import"FractionB.h"
15. #import
17. @implementationFractionB
19. -(void)print{
21. printf("(%i/%i)",numerator,denominator);
23. }
25. @end
27. main.m
29. #import
31. #import"Fraction.h"
33. #import"FractionB.h"
35. intmain(intargc,constchar*argv[]){
37. Fraction*frac=[[Fractionalloc]initWithNumerator:3denominator:10];
39. //printit
41. printf("Thefractionis:");
43. [fracprint];
45. printf("\n");
47. //makeFractionBposeasFraction
49. [FractionBposeAsClass:[Fractionclass]];
51. Fraction*frac2=[[Fractionalloc]initWithNumerator:3denominator:10];
53. //printit
55. printf("Thefractionis:");
57. [frac2print];
59. printf("\n");
61. //freememory
63. [fracrelease];
65. [frac2release];
67. return0;
69. }

output

1. Thefractionis:3/10
3. Thefractionis:(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
3. @protocolPrinting
5. -(void)print;
7. @end
9. Fraction.h
11. #import
13. #import"Printing.h"
15. @interfaceFraction:NSObject{
17. intnumerator;
19. intdenominator;
21. }
23. -(Fraction*)initWithNumerator:(int)ndenominator:(int)d;
25. -(void)setNumerator:(int)d;
27. -(void)setDenominator:(int)d;
29. -(void)setNumerator:(int)nandDenominator:(int)d;
31. -(int)numerator;
33. -(int)denominator;
35. @end
37. Fraction.m
39. #import"Fraction.h"
41. #import
43. @implementationFraction
45. -(Fraction*)initWithNumerator:(int)ndenominator:(int)d{
47. self=[superinit];
49. if(self){
51. [selfsetNumerator:nandDenominator:d];
53. }
55. returnself;
57. }
59. -(void)print{
61. printf("%i/%i",numerator,denominator);
63. }
65. -(void)setNumerator:(int)n{
67. nnumerator=n;
69. }
71. -(void)setDenominator:(int)d{
73. ddenominator=d;
75. }
77. -(void)setNumerator:(int)nandDenominator:(int)d{
79. nnumerator=n;
81. ddenominator=d;
83. }
85. -(int)denominator{
87. returndenominator;
89. }
91. -(int)numerator{
93. returnnumerator;
95. }
97. -(Fraction*)copyWithZone:(NSZone*)zone{
99. return[[FractionallocWithZone:zone]initWithNumerator:numerator
101. denominator:denominator];
103. }
105. @end
107. Complex.h
109. #import
111. #import"Printing.h"
113. @interfaceComplex:NSObject{
115. doublereal;
117. doubleimaginary;
119. }
121. -(Complex*)initWithReal:(double)randImaginary:(double)i;
123. -(void)setReal:(double)r;
125. -(void)setImaginary:(double)i;
127. -(void)setReal:(double)randImaginary:(double)i;
129. -(double)real;
131. -(double)imaginary;
133. @end
135. Complex.m
137. #import"Complex.h"
139. #import
141. @implementationComplex
143. -(Complex*)initWithReal:(double)randImaginary:(double)i{
145. self=[superinit];
147. if(self){
149. [selfsetReal:randImaginary:i];
151. }
153. returnself;
155. }
157. -(void)setReal:(double)r{
159. rreal=r;
161. }
163. -(void)setImaginary:(double)i{
165. iimaginary=i;
167. }
169. -(void)setReal:(double)randImaginary:(double)i{
171. rreal=r;
173. iimaginary=i;
175. }
177. -(double)real{
179. returnreal;
181. }
183. -(double)imaginary{
185. returnimaginary;
187. }
189. -(void)print{
191. printf("%_f+%_fi",real,imaginary);
193. }
195. @end
197. main.m
199. #import
201. #import"Fraction.h"
203. #import"Complex.h"
205. intmain(intargc,constchar*argv[]){
207. //createanewinstance
209. Fraction*frac=[[Fractionalloc]initWithNumerator:3denominator:10];
211. Complex*comp=[[Complexalloc]initWithReal:5andImaginary:15];
213. idprintable;
215. idcopyPrintable;
217. //printit
219. printable=frac;
221. printf("Thefractionis:");
223. [printableprint];
225. printf("\n");
227. //printcomplex
229. printable=comp;
231. printf("Thecomplexnumberis:");
233. [printableprint];
235. printf("\n");
237. //thiscompilesbecauseFractioncomformstobothPrintingandNSCopyable
239. copyPrintable=frac;
241. //thisdoesn'tcompilebecauseComplexonlyconformstoPrinting
243. //copyPrintable=comp;
245. //testconformance
247. //true
249. if([fracconformsToProtocol:@protocol(NSCopying)]==YES){
251. printf("FractionconformstoNSCopying\n");
253. }
255. //false
257. if([compconformsToProtocol:@protocol(NSCopying)]==YES){
259. printf("ComplexconformstoNSCopying\n");
261. }
263. //freememory
265. [fracrelease];
267. [comprelease];
269. return0;
271. }

output

1. Thefractionis:3/10
3. Thecomplexnumberis:5.000000+15.000000i
5. FractionconformstoNSCopying

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 )]。