本文为台湾出版的《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
- hello.m
- #import
- int main( int argc, const char *argv[] ) {
- printf( "hello world\n" );
- return 0;
- }
输出
helloworld
在Objective-C中使用#import代替#include
Objective-C的预设副档名是.m
创建classes
@interface
- 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
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
- Fraction.m
- #import "Fraction.h"
- #import
- @implementation Fraction
- -(void) print {
- printf( "%i/%i", numerator, denominator );
- }
- -(void) setNumerator: (int) n {
- nnumerator = n;
- }
- -(void) setDenominator: (int) d {
- ddenominator = d;
- }
- -(int) denominator {
- return denominator;
- }
- -(int) numerator {
- return numerator;
- }
- @end
Implementation 以 @implementation ClassName 开始,以 @end 结束。
Implement 定义好的 methods 的方式,跟在 interface 中宣告时很近似。
把它们凑在一起
- 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
- The fraction is: 1/3
- Fraction *frac = [[Fraction alloc] 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 版本。
- Fraction.h
- ...
- -(void) setNumerator: (int) n andDenominator: (int) d;
- ...
- Fraction.m
- ...
- -(void) setNumerator: (int) n andDenominator: (int) d {
- nnumerator = n;
- ddenominator = 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
- The fraction is: 1/3
- Fraction 2 is: 1/5
这个 method 实际上叫做 setNumerator:andDenominator:
加入其他参数的方法就跟加入第二个时一样,即 method:label1:label2:label3: ,而唿叫的方法是 [obj method: param1 label1: param2 label2: param3 label3: param4]
Labels 是非必要的,所以可以有一个像这样的 method:method:::,简单的省略 label 名称,但以 : 区隔参数。并不建议这样使用。
建构子(Constructors)
- 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
- The fraction is: 1/3
- Fraction 2 is: 1/5
- Fraction 3 is: 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)的方式。
- Access.h
- #import
- @interface Access: NSObject {
- @public
- int publicVar;
- @private
- int privateVar;
- int privateVar2;
- @protected
- int protectedVar;
- }
- @end
- Access.m
- #import "Access.h"
- @implementation Access
- @end
- main.m
- #import "Access.h"
- #import
- int main( int argc, const char *argv[] ) {
- Access *a = [[Access alloc] init];
- // works
- a->publicVar = 5;
- printf( "public var: %i\n", a->publicVar );
- // doesn't compile
- //a->privateVar = 10;
- //printf( "private var: %i\n", a->privateVar );
- [a release];
- return 0;
- }
output
- public var: 5
如同你所看到的,就像 C++ 中 private: [list of vars] public: [list of vars] 的格式,它只是改成了@private, @protected, 等等。
Class level access
- ClassA.h
- #import
- static int count;
- @interface ClassA: NSObject
- +(int) initCount;
- +(void) initialize;
- @end
- ClassA.m
- #import "ClassA.h"
- @implementation ClassA
- -(id) init {
- self = [super init];
- count++;
- return self;
- }
- +(int) initCount {
- return count;
- }
- +(void) initialize {
- count = 0;
- }
- @end
- main.m
- #import "ClassA.h"
- #import
- int main( int argc, const char *argv[] ) {
- ClassA *c1 = [[ClassA alloc] init];
- ClassA *c2 = [[ClassA alloc] init];
- // print count
- printf( "ClassA count: %i\n", [ClassA initCount] );
- ClassA *c3 = [[ClassA alloc] init];
- // print count again
- printf( "ClassA count: %i\n", [ClassA initCount] );
- [c1 release];
- [c2 release];
- [c3 release];
- return 0;
- }
output
- ClassA count: 2
- ClassA count: 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 以上才支援。
- CupWarningException.h
- #import
- @interface CupWarningException: NSException
- @end
- CupWarningException.m
- #import "CupWarningException.h"
- @implementation CupWarningException
- @end
- CupOverflowException.h
- #import
- @interface CupOverflowException: NSException
- @end
- CupOverflowException.m
- #import "CupOverflowException.h"
- @implementation CupOverflowException
- @end
- Cup.h
- #import
- @interface Cup: NSObject {
- int level;
- }
- -(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
- @implementation Cup
- -(id) init {
- self = [super init];
- if ( self ) {
- [self setLevel: 0];
- }
- return self;
- }
- -(int) level {
- return level;
- }
- -(void) setLevel: (int) l {
- llevel = l;
- if ( level > 100 ) {
- // throw overflow
- NSException *e = [CupOverflowException
- exceptionWithName: @"CupOverflowException"
- reason: @"The level is above 100"
- userInfo: nil];
- @throw e;
- } else if ( level >= 50 ) {
- // throw warning
- NSException *e = [CupWarningException
- exceptionWithName: @"CupWarningException"
- reason: @"The level is above or at 50"
- userInfo: nil];
- @throw e;
- } else if ( level < 0 ) {
- // throw exception
- NSException *e = [NSException
- exceptionWithName: @"CupUnderflowException"
- reason: @"The level is below 0"
- userInfo: nil];
- @throw e;
- }
- }
- -(void) fill {
- [self setLevel: level + 10];
- }
- -(void) empty {
- [self setLevel: level - 10];
- }
- -(void) print {
- printf( "Cup level is: %i\n", level );
- }
- @end
- main.m
- #import "Cup.h"
- #import "CupOverflowException.h"
- #import "CupWarningException.h"
- #import
- #import
- #import
- #import
- int main( int argc, const char *argv[] ) {
- NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init];
- Cup *cup = [[Cup alloc] init];
- int i;
- // this will work
- for ( i = 0; i < 4; i++ ) {
- [cup fill];
- [cup print];
- }
- // this will throw exceptions
- for ( i = 0; i < 7; i++ ) {
- @try {
- [cup fill];
- } @catch ( CupWarningException *e ) {
- printf( "%s: ", [[e name] cString] );
- } @catch ( CupOverflowException *e ) {
- printf( "%s: ", [[e name] cString] );
- } @finally {
- [cup print];
- }
- }
- // throw a generic exception
- @try {
- [cup setLevel: -1];
- } @catch ( NSException *e ) {
- printf( "%s: %s\n", [[e name] cString], [[e reason] cString] );
- }
- // free memory
- [cup release];
- [pool release];
- }
output
- Cup level is: 10
- Cup level is: 20
- Cup level is: 30
- Cup level is: 40
- CupWarningException: Cup level is: 50
- CupWarningException: Cup level is: 60
- CupWarningException: Cup level is: 70
- CupWarningException: Cup level is: 80
- CupWarningException: Cup level is: 90
- CupWarningException: Cup level is: 100
- CupOverflowException: Cup level is: 110
- CupUnderflowException: The level is below 0
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 *。