Objective-C 语法
前言
这篇教学假设你已经有一些基本的 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
hello.m
#import <stdio.h>
int main( int argc, const char *argv[] ) {
printf( "hello world\n" );
return 0;
} 輸出： hello world
在 Objective-C 中使用 #import 代替 #includeObjective-C 的预设副档名是 .m
创建 classes @interface
基于 "Programming in Objective-C," Copyright © 2004 by Sams Publishing 一书中的范例，并经过允许而刊载。
Fraction.h
#import
@interface Fraction: NSObject {
int numerator;
int denominator;
}
-(void) print;
-(void) setNumerator: (int) n;
-(void) setDenominator: (int) d;
-(int) numerator;
-(int) denominator;
@end 1. NSObject：NeXTStep Object 的缩写。因为它已经改名为 OpenStep，所以这在今天已经不是那么有意义了。
2.继承（inheritance）以Class:Parent表示，就像上面的Fraction:NSObject。
3.夹在@interfaceClass:Parent{....}中的称为instancevariables。
4.没有设定存取权限（protected,public,private）时，预设的存取权限为protected。设定权限的方式将在稍后说明。
5. Instance methods 跟在成员变数（即 instance variables）后。格式为：scope (returnType) methodName: (parameter1Type) parameter1Name;
scope有class或instance两种。instancemethods以-开头，classlevelmethods以+开头。
6. Interface 以一个 @end 作为结束。@implementation
基于 "Programming in Objective-C," Copyright © 2004 by Sams Publishing 一书中的范例，并经过允许而刊载。
Fraction.m
#import "Fraction.h"
#import
@implementation Fraction
-(void) print {
printf( "%i/%i", numerator, denominator );
}
-(void) setNumerator: (int) n {
numerator = n;
}
-(void) setDenominator: (int) d {
denominator = d;
}
-(int) denominator {
return denominator;
}
-(int) numerator {
return numerator;
}
@end 1. Implementation 以 @implementation ClassName 开始，以 @end 结束。2. Implement 定义好的 methods 的方式，跟在 interface 中宣告时很近似。
把它们凑在一起
基于 "Programming in Objective-C," Copyright © 2004 by Sams Publishing 一书中的范例，并经过允许而刊载。
main.m
#import
#import "Fraction.h"
int main( int argc, const char *argv[] ) {
// create a new instance
Fraction *frac = [[Fraction alloc] init];
// set the values
[frac setNumerator: 1];
[frac setDenominator: 3];
// print it
printf( "The fraction is: " );
[frac print];
printf( "\n" );
// free memory
[frac release];
return 0;
} output
Thefractionis:1/3
Fraction *frac = [[Fraction alloc] init]; 这行程式码中有很多重要的东西。1.在Objective-C中呼叫methods的方法是[objectmethod]，就像C++的object->method()。
2.Objective-C没有value型别。所以没有像C++的Fractionfrac;frac.print();这类的东西。在Objective-C中完全使用指标来处理物件。
3.这行程式码实际上做了两件事：[Fractionalloc]呼叫了Fractionclass的allocmethod。这就像malloc记忆体，这个动作也做了一样的事情。
4.[objectinit]是一个建构子（constructor）呼叫，负责初始化物件中的所有变数。它呼叫了[Fractionalloc]传回的instance上的initmethod。这个动作非常普遍，所以通常以一行程式完成：Object*var=[[Objectalloc]init];
6.[fracsetNumerator:1]非常简单。它呼叫了frac上的setNumeratormethod并传入1为参数。
7. 如同每个 C 的变体，Objective-C 也有一个用以释放记忆体的方式： release。它继承自 NSObject，这个 method 在之后会有详尽的解说。详细说明... 多重参数
目前为止我还没展示如何传递多个参数。这个语法乍看之下不是很直觉，不过它却是来自一个十分受欢迎的 Smalltalk 版本。
基于 "Programming in Objective-C," Copyright © 2004 by Sams Publishing一书中的范例，并经过允许而刊载。
Fraction.h
... -(void) setNumerator: (int) n andDenominator: (int) d; ...
Fraction.m
...
-(void) setNumerator: (int) n andDenominator: (int) d {
numerator = n;
denominator = d;
}
...main.m
#import
#import "Fraction.h"
int main( int argc, const char *argv[] ) {
// create a new instance
Fraction *frac = [[Fraction alloc] init];
Fraction *frac2 = [[Fraction alloc] init];
// set the values
[frac setNumerator: 1];
[frac setDenominator: 3];
// combined set
[frac2 setNumerator: 1 andDenominator: 5];
// print it
printf( "The fraction is: " );
[frac print];
printf( "\n" );
// print it
printf( "Fraction 2 is: " );
[frac2 print];
printf( "\n" );
// free memory
[frac release];
[frac2 release];
return 0;
}
output
Thefractionis:1/3
Fraction2is:1/5
1.这个method实际上叫做setNumerator:andDenominator:
2.加入其他参数的方法就跟加入第二个时一样，即method:label1:label2:label3:，而呼叫的方法是[objmethod:param1label1:param2label2:param3label3:param4]
3. Labels 是非必要的，所以可以有一个像这样的 method：method:::，简单的省略 label 名称，但以 : 区隔参数。并不建议这样使用。建构子（Constructors）
基于 "Programming in Objective-C," Copyright © 2004 by Sams Publishing一书中的范例，并经过允许而刊载。
Fraction.h
... -(Fraction*) initWithNumerator: (int) n denominator: (int) d; ...
Fraction.m
...
-(Fraction*) initWithNumerator: (int) n denominator: (int) d {
self = [super init];
if ( self ) {
[self setNumerator: n andDenominator: d];
}
return self;
}
... main.m
#import
#import "Fraction.h"
int main( int argc, const char *argv[] ) {
// create a new instance
Fraction *frac = [[Fraction alloc] init];
Fraction *frac2 = [[Fraction alloc] init];
Fraction *frac3 = [[Fraction alloc] initWithNumerator: 3 denominator: 10];
// set the values
[frac setNumerator: 1];
[frac setDenominator: 3];
// combined set
[frac2 setNumerator: 1 andDenominator: 5];
// print it
printf( "The fraction is: " );
[frac print];
printf( "\n" );
printf("Fraction 2 is: " );
[frac2 print];
printf( "\n" );
printf( "Fraction 3 is: " );
[frac3 print];
printf( "\n" );
// free memory
[frac release];
[frac2 release];
[frac3 release];
return 0;
} output
Thefractionis:1/3
Fraction2is:1/5
Fraction3is:3/10
1.@interface里的宣告就如同正常的函式。
2.@implementation使用了一个新的关键字：super
3.如同Java，Objective-C只有一个parentclass（父类别）。
4.使用[superinit]来存取Superconstructor，这个动作需要适当的继承设计。
5.你将这个动作回传的instance指派给另一新个关键字：self。Self很像C++与Java的this指标。
6.if(self)跟(self!=nil)一样，是为了确定superconstructor成功传回了一个新物件。nil是Objective-C用来表达C/C++中NULL的方式，可以引入NSObject来取得。
7.当你初始化变数以后，你用传回self的方式来传回自己的位址。
8.预设的建构子是-(id)init。
9. 技术上来说，Objective-C 中的建构子就是一个 "init" method，而不像 C++ 与 Java 有特殊的结构。存取权限
预设的权限是@protected
Java 实作的方式是在 methods 与变数前面加上 public/private/protected 修饰语，而 Objective-C 的作法则更像 C++ 对于 instance variable（译注：C++ 术语一般称为 data members）的方式。Access.h
#import
@interfaceAccess:NSObject{
@public
intpublicVar;
@private
intprivateVar;
intprivateVar2;
@protected
intprotectedVar;
}
@end
Access.m
#import\"Access.h\"
@implementationAccess
@end
main.m
#import\"Access.h\"
#import
intmain(intargc,constchar*argv[]){
Access*a=[[Accessalloc]init];
//works
a->publicVar=5;
printf(\"publicvar:%i\\n\",a->publicVar);
//doesn\'tcompile
//a->privateVar=10;
//printf(\"privatevar:%i\\n\",a->privateVar);
[arelease];
return0;
}
output
publicvar:5
如同你所看到的，就像C++中private:[listofvars]public:[listofvars]的格式，它只是改成了@private,@protected,等等。
Classlevelaccess
当你想计算一个物件被instance几次时，通常有classlevelvariables以及classlevelfunctions是件方便的事。
ClassA.h
#import
staticintcount;
@interfaceClassA:NSObject
+(int)initCount;
+(void)initialize;
@end
ClassA.m
#import\"ClassA.h\"
@implementationClassA
-(id)init{
self=[superinit];
count++;
returnself;
}
+(int)initCount{
returncount;
}
+(void)initialize{
count=0;
}
@end
main.m
#import\"ClassA.h\"
#import
intmain(intargc,constchar*argv[]){
ClassA*c1=[[ClassAalloc]init];
ClassA*c2=[[ClassAalloc]init];
//printcount
printf(\"ClassAcount:%i\\n\",[ClassAinitCount]);
ClassA*c3=[[ClassAalloc]init];
//printcountagain
printf(\"ClassAcount:%i\\n\",[ClassAinitCount]);
[c1release];
[c2release];
[c3release];
return0;
}
output
ClassAcount:2
ClassAcount:3
staticintcount=0;这是classvariable宣告的方式。其实这种变数摆在这里并不理想，比较好的解法是像Java实作staticclassvariables的方法。然而，它确实能用。
+(int)initCount;这是回传count值的实际method。请注意这细微的差别！这里在type前面不用减号-而改用加号+。加号+表示这是一个classlevelfunction。（译注：许多文件中，classlevelfunctions被称为classfunctions或classmethod）
存取这个变数跟存取一般成员变数没有两样，就像ClassA中的count++用法。
+(void)initializemethodis在Objective-C开始执行你的程式时被呼叫，而且它也被每个class呼叫。这是初始化像我们的count这类classlevelvariables的好地方。
异常情况（Exceptions）
注意：异常处理只有MacOSX10.3以上才支援。
基于\"ProgramminginObjective-C,\"Copyright©2004bySamsPublishing一书中的范例，并经过允许而刊载。
CupWarningException.h
#import
@interfaceCupWarningException:NSException
@end
CupWarningException.m
#import\"CupWarningException.h\"
@implementationCupWarningException
@end
CupOverflowException.h
#import
@interfaceCupOverflowException:NSException
@end
CupOverflowException.m
#import\"CupOverflowException.h\"
@implementationCupOverflowException
@end
Cup.h
#import
@interfaceCup:NSObject{
intlevel;
}
-(int)level;
-(void)setLevel:(int)l;
-(void)fill;
-(void)empty;
-(void)print;
@end
Cup.m
#import\"Cup.h\"
#import\"CupOverflowException.h\"
#import\"CupWarningException.h\"
#import
#import
@implementationCup
-(id)init{
self=[superinit];
if(self){
[selfsetLevel:0];
}
returnself;
}
-(int)level{
returnlevel;
}
-(void)setLevel:(int)l{
level=l;
if(level>100){
//throwoverflow
NSException*e=[CupOverflowException
exceptionWithName:@\"CupOverflowException\"
reason:@\"Thelevelisabove100\"
userInfo:nil];
@throwe;
}elseif(level>=50){
//throwwarning
NSException*e=[CupWarningException
exceptionWithName:@\"CupWarningException\"
reason:@\"Thelevelisaboveorat50\"
userInfo:nil];
@throwe;
}elseif(level<0){
//throwexception
NSException*e=[NSException
exceptionWithName:@\"CupUnderflowException\"
reason:@\"Thelevelisbelow0\"
userInfo:nil];
@throwe;
}
}
-(void)fill{
[selfsetLevel:level+10];
}
-(void)empty{
[selfsetLevel:level-10];
}
-(void)print{
printf(\"Cuplevelis:%i\\n\",level);
}
@end
main.m
#import\"Cup.h\"
#import\"CupOverflowException.h\"
#import\"CupWarningException.h\"
#import
#import
#import
#import
intmain(intargc,constchar*argv[]){
NSAutoreleasePool*pool=[[NSAutoreleasePoolalloc]init];
Cup*cup=[[Cupalloc]init];
inti;
//thiswillwork
for(i=0;i<4;i++){
[cupfill];
[cupprint];
}
//thiswillthrowexceptions
for(i=0;i<7;i++){
@try{
[cupfill];
}@catch(CupWarningException*e){
printf(\"%s:\",[[ename]cString]);
}@catch(CupOverflowException*e){
printf(\"%s:\",[[ename]cString]);
}@finally{
[cupprint];
}
}
//throwagenericexception
@try{
[cupsetLevel:-1];
}@catch(NSException*e){
printf(\"%s:%s\\n\",[[ename]cString],[[ereason]cString]);
}
//freememory
[cuprelease];
[poolrelease];
}
output
Cuplevelis:10
Cuplevelis:20
Cuplevelis:30
Cuplevelis:40
CupWarningException:Cuplevelis:50
CupWarningException:Cuplevelis:60
CupWarningException:Cuplevelis:70
CupWarningException:Cuplevelis:80
CupWarningException:Cuplevelis:90
CupWarningException:Cuplevelis:100
CupOverflowException:Cuplevelis:110
CupUnderflowException:Thelevelisbelow0
NSAutoreleasePool是一个记忆体管理类别。现在先别管它是干嘛的。
Exceptions（异常情况）的丢出不需要扩充（extend）NSException物件，你可简单的用id来代表它：@catch(ide){...}
还有一个finally区块，它的行为就像Java的异常处理方式，finally区块的内容保证会被呼叫。
Cup.m 里的 @\"CupOverflowException\" 是一个 NSString 常数物件。在 Objective-C 中，@ 符号通常用来代表这是语言的衍生部分。C 语言形式的字串（C string）就像 C/C++ 一样是 \"String constant\" 的形式，型别为 char *。