Objective-C学习大纲 一

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

AD：

所有这篇初学者指南的塬始码都可以由 objc.tar.gz 下载。这篇教学中的许多範例都是由 Steve Kochan 在 Programming in Objective-C. 一书中撰写。如果你想得到更多详细资讯及範例，请直接参考该书。这个网站上登载的所有範例皆经过他的允许，所以请勿复製转载。

设定环境

Linux/FreeBSD: 安装 GNUStep

为了编译 GNUstep 应用程式，必须先执行位于 /usr/GNUstep/System/Makefiles/GNUstep.sh 的 GNUstep.sh 这个档案。这个路径取决于你的系统环境，有些是在 /usr, some /usr/lib，有些是 /usr/local。如果你的 shell 是以 csh/tcsh 为基础的 shell，则应该改用 GNUStep.csh。建议把这个指令放在 .bashrc 或 .cshrc 中。

Mac OS X: 安装 XCode

Windows NT 5.X: 安装 cygwin 或 mingw，然后安装 GNUStep

前言

这篇教学假设你已经有一些基本的 C 语言知识，包括 C 资料型别、什么是函式、什么是回传值、关于指标的知识以及基本的 C 语言记忆体管理。如果您没有这些背景知识，我非常建议你读一读 K&R 的书：The C Programming Language(译注：台湾出版书名为 C 程式语言第二版)这是 C 语言的设计者所写的书。

Objective-C，是 C 的衍生语言，继承了所有 C 语言的特性。是有一些例外，但是它们不是继承于 C 的语言特性本身。

nil：在 C/C++ 你或许曾使用过 NULL，而在 Objective-C 中则是 nil。不同之处是你可以传递讯息给 nil(例如 [nil message];)，这是完全合法的，然而你却不能对 NULL 如法炮製。

BOOL：C 没有正式的布林型别，而在 Objective-C 中也不是「真的」有。它是包含在 Foundation classes(基本类别库)中(即 import NSObject.h;nil 也是包括在这个标头档内)。BOOL 在 Objective-C 中有两种型态：YES 或 NO，而不是 TRUE 或 FALSE。

#import vs #include：就如同你在 hello world 範例中看到的，我们使用了 #import。#import 由 gcc 编译器支援。我并不建议使用 #include，#import 基本上跟 .h 档头尾的 #ifndef #define #endif 相同。许多程式员们都同意，使用这些东西这是十分愚蠢的。无论如何，使用 #import 就对了。这样不但可以避免麻烦，而且万一有一天 gcc 把它拿掉了，将会有足够的 Objective-C 程式员可以坚持保留它或是将它放回来。偷偷告诉你，Apple 在它们官方的程式码中也使用了 #import。所以万一有一天这种事真的发生，不难预料 Apple 将会提供一个支援 #import 的 gcc 分支版本。

在 Objective-C 中， method 及 message 这两个字是可以互换的。不过 messages 拥有特别的特性，一个 message 可以动态的转送给另一个物件。在 Objective-C 中，唿叫物件上的一个讯息并不一定表示物件真的会实作这个讯息，而是物件知道如何以某种方式去实作它，或是转送给知道如何实作的物件。

编译 hello world

1. hello.m
3. #import
5. intmain(intargc,constchar*argv[]){
7. printf("helloworld\n");
9. return0;
11. }

输出

helloworld

在Objective-C中使用#import代替#include

Objective-C的预设副档名是.m

创建classes

@interface

3. Fraction.h
5. #import
7. @interfaceFraction:NSObject{
9. intnumerator;
11. intdenominator;
13. }
15. -(void)print;
17. -(void)setNumerator:(int)n;
19. -(void)setDenominator:(int)d;
21. -(int)numerator;
23. -(int)denominator;
25. @end

NSObject：NeXTStep Object 的缩写。因为它已经改名为 OpenStep，所以这在今天已经不是那么有意义了。

继承(inheritance)以 Class: Parent 表示，就像上面的 Fraction: NSObject。

夹在 @interface Class: Parent { .... } 中的称为 instance variables。

没有设定存取权限(protected, public, private)时，预设的存取权限为 protected。设定权限的方式将在稍后说明。

Instance methods 跟在成员变数(即 instance variables)后。格式为：scope (returnType) methodName: (parameter1Type) parameter1Name;

scope 有class 或 instance 两种。instance methods 以 - 开头，class level methods 以 + 开头。

Interface 以一个 @end 作为结束。

@implementation

1. Fraction.m
3. #import"Fraction.h"
5. #import
7. @implementationFraction
9. -(void)print{
11. printf("%i/%i",numerator,denominator);
13. }
15. -(void)setNumerator:(int)n{
17. nnumerator=n;
19. }
21. -(void)setDenominator:(int)d{
23. ddenominator=d;
25. }
27. -(int)denominator{
29. returndenominator;
31. }
33. -(int)numerator{
35. returnnumerator;
37. }
39. @end

Implementation 以 @implementation ClassName 开始，以 @end 结束。

Implement 定义好的 methods 的方式，跟在 interface 中宣告时很近似。

把它们凑在一起

1. main.m
3. #import
5. #import"Fraction.h"
7. intmain(intargc,constchar*argv[]){
9. //createanewinstance
11. Fraction*frac=[[Fractionalloc]init];
13. //setthevalues
15. [fracsetNumerator:1];
17. [fracsetDenominator:3];
19. //printit
21. printf("Thefractionis:");
23. [fracprint];
25. printf("\n");
27. //freememory
29. [fracrelease];
31. return0;
33. }

output

1. Thefractionis:1/3
3. Fraction*frac=[[Fractionalloc]init];

这行程式码中有很多重要的东西。

在 Objective-C 中唿叫 methods 的方法是 [object method]，就像 C++ 的 object->method()。

Objective-C 没有 value 型别。所以没有像 C++ 的 Fraction frac; frac.print(); 这类的东西。在 Objective-C 中完全使用指标来处理物件。

这行程式码实际上做了两件事： [Fraction alloc] 唿叫了 Fraction class 的 alloc method。这就像 malloc 记忆体，这个动作也做了一样的事情。

[object init] 是一个建构子(constructor)唿叫，负责初始化物件中的所有变数。它唿叫了 [Fraction alloc] 传回的 instance 上的 init method。这个动作非常普遍，所以通常以一行程式完成：Object *var = [[Object alloc] init];

[frac setNumerator: 1] 非常简单。它唿叫了 frac 上的 setNumerator method 并传入 1 为参数。

如同每个 C 的变体，Objective-C 也有一个用以释放记忆体的方式： release。它继承自 NSObject，这个 method 在之后会有详尽的解说。

详细说明...

多重参数

目前为止我还没展示如何传递多个参数。这个语法乍看之下不是很直觉，不过它却是来自一个十分受欢迎的 Smalltalk 版本。

1. Fraction.h
3. ...
5. -(void)setNumerator:(int)nandDenominator:(int)d;
7. ...
9. Fraction.m
11. ...
13. -(void)setNumerator:(int)nandDenominator:(int)d{
15. nnumerator=n;
17. ddenominator=d;
19. }
21. ...
23. main.m
25. #import
27. #import"Fraction.h"
29. intmain(intargc,constchar*argv[]){
31. //createanewinstance
33. Fraction*frac=[[Fractionalloc]init];
35. Fraction*frac2=[[Fractionalloc]init];
37. //setthevalues
39. [fracsetNumerator:1];
41. [fracsetDenominator:3];
43. //combinedset
45. [frac2setNumerator:1andDenominator:5];
47. //printit
49. printf("Thefractionis:");
51. [fracprint];
53. printf("\n");
55. //printit
57. printf("Fraction2is:");
59. [frac2print];
61. printf("\n");
63. //freememory
65. [fracrelease];
67. [frac2release];
69. return0;
71. }

output

1. Thefractionis:1/3
3. Fraction2is:1/5

这个 method 实际上叫做 setNumerator:andDenominator:

加入其他参数的方法就跟加入第二个时一样，即 method:label1:label2:label3: ，而唿叫的方法是 [obj method: param1 label1: param2 label2: param3 label3: param4]

Labels 是非必要的，所以可以有一个像这样的 method：method:::，简单的省略 label 名称，但以 : 区隔参数。并不建议这样使用。

建构子(Constructors)

1. Fraction.h
3. ...
5. -(Fraction*)initWithNumerator:(int)ndenominator:(int)d;
7. ...
9. Fraction.m
11. ...
13. -(Fraction*)initWithNumerator:(int)ndenominator:(int)d{
15. self=[superinit];
17. if(self){
19. [selfsetNumerator:nandDenominator:d];
21. }
23. returnself;
25. }
27. ...
29. main.m
31. #import
33. #import"Fraction.h"
35. intmain(intargc,constchar*argv[]){
37. //createanewinstance
39. Fraction*frac=[[Fractionalloc]init];
41. Fraction*frac2=[[Fractionalloc]init];
43. Fraction*frac3=[[Fractionalloc]initWithNumerator:3denominator:10];
45. //setthevalues
47. [fracsetNumerator:1];
49. [fracsetDenominator:3];
51. //combinedset
53. [frac2setNumerator:1andDenominator:5];
55. //printit
57. printf("Thefractionis:");
59. [fracprint];
61. printf("\n");
63. printf("Fraction2is:");
65. [frac2print];
67. printf("\n");
69. printf("Fraction3is:");
71. [frac3print];
73. printf("\n");
75. //freememory
77. [fracrelease];
79. [frac2release];
81. [frac3release];
83. return0;
85. }

output

1. Thefractionis:1/3
3. Fraction2is:1/5
5. Fraction3is:3/10

@interface 裡的宣告就如同正常的函式。

@implementation 使用了一个新的关键字：super

如同 Java，Objective-C 只有一个 parent class(父类别)。

使用 [super init] 来存取 Super constructor，这个动作需要适当的继承设计。

你将这个动作回传的 instance 指派给另一新个关键字：self。Self 很像 C++ 与 Java 的 this 指标。

if ( self ) 跟 ( self != nil ) 一样，是为了确定 super constructor 成功传回了一个新物件。nil 是 Objective-C 用来表达 C/C++ 中 NULL 的方式，可以引入 NSObject 来取得。

当你初始化变数以后，你用传回 self 的方式来传回自己的位址。

预设的建构子是 -(id) init。

技术上来说，Objective-C 中的建构子就是一个 "init" method，而不像 C++ 与 Java 有特殊的结构。

存取权限

预设的权限是 @protected

Java 实作的方式是在 methods 与变数前面加上 public/private/protected 修饰语，而 Objective-C 的作法则更像 C++ 对于 instance variable(译注：C++ 术语一般称为 data members)的方式。

1. Access.h
3. #import
5. @interfaceAccess:NSObject{
7. @public
9. intpublicVar;
11. @private
13. intprivateVar;
15. intprivateVar2;
17. @protected
19. intprotectedVar;
21. }
23. @end
25. Access.m
27. #import"Access.h"
29. @implementationAccess
31. @end
33. main.m
35. #import"Access.h"
37. #import
39. intmain(intargc,constchar*argv[]){
41. Access*a=[[Accessalloc]init];
43. //works
45. a->publicVar=5;
47. printf("publicvar:%i\n",a->publicVar);
49. //doesn'tcompile
51. //a->privateVar=10;
53. //printf("privatevar:%i\n",a->privateVar);
55. [arelease];
57. return0;
59. }

output

1. publicvar:5

如同你所看到的，就像 C++ 中 private: [list of vars] public: [list of vars] 的格式，它只是改成了@private, @protected, 等等。

Class level access

1. ClassA.h
3. #import
5. staticintcount;
7. @interfaceClassA:NSObject
9. +(int)initCount;
11. +(void)initialize;
13. @end
15. ClassA.m
17. #import"ClassA.h"
19. @implementationClassA
21. -(id)init{
23. self=[superinit];
25. count++;
27. returnself;
29. }
31. +(int)initCount{
33. returncount;
35. }
37. +(void)initialize{
39. count=0;
41. }
43. @end
45. main.m
47. #import"ClassA.h"
49. #import
51. intmain(intargc,constchar*argv[]){
53. ClassA*c1=[[ClassAalloc]init];
55. ClassA*c2=[[ClassAalloc]init];
57. //printcount
59. printf("ClassAcount:%i\n",[ClassAinitCount]);
61. ClassA*c3=[[ClassAalloc]init];
63. //printcountagain
65. printf("ClassAcount:%i\n",[ClassAinitCount]);
67. [c1release];
69. [c2release];
71. [c3release];
73. return0;
75. }

output

1. ClassAcount:2
3. ClassAcount:3

static int count = 0; 这是 class variable 宣告的方式。其实这种变数摆在这裡并不理想，比较好的解法是像 Java 实作 static class variables 的方法。然而，它确实能用。

+(int) initCount; 这是回传 count 值的实际 method。请注意这细微的差别!这裡在 type 前面不用减号 - 而改用加号 +。加号 + 表示这是一个 class level function。(译注：许多文件中，class level functions 被称为 class functions 或 class method)

存取这个变数跟存取一般成员变数没有两样，就像 ClassA 中的 count++ 用法。

+(void) initialize method is 在 Objective-C 开始执行你的程式时被唿叫，而且它也被每个 class 唿叫。这是初始化像我们的 count 这类 class level variables 的好地方。

异常情况(Exceptions)

注意：异常处理只有 Mac OS X 10.3 以上才支援。

1. CupWarningException.h
3. #import
5. @interfaceCupWarningException:NSException
7. @end
9. CupWarningException.m
11. #import"CupWarningException.h"
13. @implementationCupWarningException
15. @end
17. CupOverflowException.h
19. #import
21. @interfaceCupOverflowException:NSException
23. @end
25. CupOverflowException.m
27. #import"CupOverflowException.h"
29. @implementationCupOverflowException
31. @end
33. Cup.h
35. #import
37. @interfaceCup:NSObject{
39. intlevel;
41. }
43. -(int)level;
45. -(void)setLevel:(int)l;
47. -(void)fill;
49. -(void)empty;
51. -(void)print;
53. @end
55. Cup.m
57. #import"Cup.h"
59. #import"CupOverflowException.h"
61. #import"CupWarningException.h"
63. #import
65. #import
67. @implementationCup
69. -(id)init{
71. self=[superinit];
73. if(self){
75. [selfsetLevel:0];
77. }
79. returnself;
81. }
83. -(int)level{
85. returnlevel;
87. }
89. -(void)setLevel:(int)l{
91. llevel=l;
93. if(level>100){
95. //throwoverflow
97. NSException*e=[CupOverflowException
99. exceptionWithName:@"CupOverflowException"
101. reason:@"Thelevelisabove100"
103. userInfo:nil];
105. @throwe;
107. }elseif(level>=50){
109. //throwwarning
111. NSException*e=[CupWarningException
113. exceptionWithName:@"CupWarningException"
115. reason:@"Thelevelisaboveorat50"
117. userInfo:nil];
119. @throwe;
121. }elseif(level<0){
123. //throwexception
125. NSException*e=[NSException
127. exceptionWithName:@"CupUnderflowException"
129. reason:@"Thelevelisbelow0"
131. userInfo:nil];
133. @throwe;
135. }
137. }
139. -(void)fill{
141. [selfsetLevel:level+10];
143. }
145. -(void)empty{
147. [selfsetLevel:level-10];
149. }
151. -(void)print{
153. printf("Cuplevelis:%i\n",level);
155. }
157. @end
159. main.m
161. #import"Cup.h"
163. #import"CupOverflowException.h"
165. #import"CupWarningException.h"
167. #import
169. #import
171. #import
173. #import
175. intmain(intargc,constchar*argv[]){
177. NSAutoreleasePool*pool=[[NSAutoreleasePoolalloc]init];
179. Cup*cup=[[Cupalloc]init];
181. inti;
183. //thiswillwork
185. for(i=0;i<4;i++){
187. [cupfill];
189. [cupprint];
191. }
193. //thiswillthrowexceptions
195. for(i=0;i<7;i++){
197. @try{
199. [cupfill];
201. }@catch(CupWarningException*e){
203. printf("%s:",[[ename]cString]);
205. }@catch(CupOverflowException*e){
207. printf("%s:",[[ename]cString]);
209. }@finally{
211. [cupprint];
213. }
215. }
217. //throwagenericexception
219. @try{
221. [cupsetLevel:-1];
223. }@catch(NSException*e){
225. printf("%s:%s\n",[[ename]cString],[[ereason]cString]);
227. }
229. //freememory
231. [cuprelease];
233. [poolrelease];
235. }

output

1. Cuplevelis:10
3. Cuplevelis:20
5. Cuplevelis:30
7. Cuplevelis:40
9. CupWarningException:Cuplevelis:50
11. CupWarningException:Cuplevelis:60
13. CupWarningException:Cuplevelis:70
15. CupWarningException:Cuplevelis:80
17. CupWarningException:Cuplevelis:90
19. CupWarningException:Cuplevelis:100
21. CupOverflowException:Cuplevelis:110
23. CupUnderflowException:Thelevelisbelow0

NSAutoreleasePool 是一个记忆体管理类别。现在先别管它是干嘛的。

Exceptions(异常情况)的丢出不需要扩充(extend)NSException 物件，你可简单的用 id 来代表它： @catch ( id e ) { ... }

还有一个 finally 区块，它的行为就像 Java 的异常处理方式，finally 区块的内容保证会被唿叫。

Cup.m 裡的 @"CupOverflowException" 是一个 NSString 常数物件。在 Objective-C 中，@ 符号通常用来代表这是语言的衍生部分。C 语言形式的字串(C string)就像 C/C++ 一样是 "String constant" 的形式，型别为 char *。