Objective-C初学指南大纲开始吧创建 classes详细说明...继承丶多型（Inheritance, Polymorphism）以及其他对象导向功能内存管理Foundation framework classes优点与缺点更多资讯

Objective-C Beginner's Guide

<a href="#gettingstarted">开始吧</a>

<a href="#downloading">下载这篇教学</a>

<a href="#settingup">设定环境</a>

<a href="#preamble">前言</a>

<a href="#helloworld">编译 hello world</a>

<a href="#creatingclasses">创建 Classes</a>

<a href="#interface">@interface</a>

<a href="#implementation">@implementation</a>

<a href="#piecing">把它们凑在一起</a>

<a href="#thedetails">详细说明...</a>

<a href="#multiple">多重参数</a>

<a href="#constructors">构造函数（Constructors）</a>

<a href="#access">存取权限</a>

<a href="#class">Class level access</a>

<a href="#exceptions">异常情况（Exceptions）处理</a>

<a href="#inheritance">继承丶多型（Inheritance, Polymorphism）以及其他对象导向功能</a>

<a href="#idtype">id 类型</a>

<a href="#subinheritance">继承（Inheritance）</a>

<a href="#dynamictypes">动态识别（Dynamic types）</a>

<a href="#categories">Categories</a>

<a href="#posing">Posing</a>

<a href="#protocols">Protocols</a>

<a href="#memorymanagement">内存管理</a>

<a href="#retain">Retain and Release（保留与释放）</a>

<a href="#dealloc">Dealloc</a>

<a href="#autorelease">Autorelease Pool</a>

<a href="#foundation">Foundation Framework Classes</a>

<a href="#nsarray">NSArray</a>

<a href="#nsdictionary">NSDictionary</a>

<a href="#prosandcons">优点与缺点</a>

<a href="#moreinfo">更多资讯</a>

<a></a>

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

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.m

输出

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

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

基于 "Programming in Objective-C," Copyright © 2004 by Sams Publishing 一书中的范例，并经过允许而刊载。

Fraction.h

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 作为结束。

Fraction.m

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

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

main.m

output

Fraction *frac = [[Fraction alloc] init];

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

在 Objective-C 中执行 methods 的方法是 [object method]，就像 C++ 的 object-&gt;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 版本。

基于 "Programming in Objective-C," Copyright © 2004 by Sams Publishing一书中的范例，并经过允许而刊载。

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

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

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

@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

Access.m

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

当你想计算一个对象被 instance 几次时，通常有 class level variables 以及 class level functions 是件方便的事。

ClassA.h

ClassA.m

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 的好地方。

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

CupWarningException.h

CupWarningException.m

CupOverflowException.h

CupOverflowException.m

Cup.h

Cup.m

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 *。

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

Complex.h

Complex.m

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

Rectangle.h

Rectangle.m

Square.h

Square.m

继承在 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 即可。

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

-(BOOL) isKindOfClass: classObj

is object a descendent or member of classObj

此对象是否是 classObj 的子孙或一员

-(BOOL) isMemberOfClass: classObj

is object a member of classObj

此对象是否是 classObj 的一员

-(BOOL) respondsToSelector: selector

does the object have a method named specifiec by the selector

此对象是否有叫做 selector 的 method

+(BOOL) instancesRespondToSelector: selector

does an object created by this class have the ability to respond

to the specified selector

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

-(id) performSelector: selector

invoke the specified selector on the object

唤起此对象的指定 selector

所有继承自 NSObject 都有一个可返回一个 class 对象的 class method。这非常近似于 Java 的 getClass()

method。这个 class 对象被使用于前述的 methods 中。

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

基于 "Programming in Objective-C," Copyright ©

2004 by Sams Publishing一书中的范例，并经过允许而刊载。

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

FractionMath.h

FractionMath.m

重点是 @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) 档案。以下是此种作法一个简短的范例。

MyClass.h

MyClass.m

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

FractionB.h

FractionB.m

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

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

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

Printing.h

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

要遵从（conform）某个 protocol，将要遵从的 protocols 放在 &lt;&gt; 里面，并以逗点分隔。如：@interface SomeClass &lt;Protocol1, Protocol2, Protocol3&gt;

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

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

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

到目前为止我都刻意避开 Objective-C 的内存管理议题。你可以执行对象上的 dealloc，但是若对象里包含其他对象的指标的话，要怎么办呢？要释放那些对象所占据的内存也是一个必须关注的问题。当你使用 Foundation framework 建立 classes 时，它如何管理内存？这些稍后我们都会解释。

注意：之前所有的范例都有正确的内存管理，以免你混淆。

Retain 以及 release 是两个继承自 NSObject 的对象都会有的 methods。每个对象都有一个内部计数器，可以用来追踪对象的 reference 个数。如果对象有 3 个 reference 时，不需要 dealloc 自己。但是如果计数器值到达 0 时，对象就得 dealloc 自己。[object retain] 会将计数器值加 1（值从 1 开始），[object release] 则将计数器值减 1。如果执行 [object release] 导致计数器到达 0，就会自动 dealloc。

Retain call 增加计数器值，而 release call 减少它。你可以执行 [obj retainCount] 来取得计数器的 int 值。 当当 retainCount 到达 0，两个对象都会 dealloc 自己，所以可以看到印出了两个 "Deallocing fraction"。

当你的对象包含其他对象时，就得在 dealloc 自己时释放它们。Objective-C 的一个优点是你可以传递消息给 nil，所以不需要经过一堆防错测试来释放一个对象。

AddressCard.h

AddressCard.m

如 AddressCard.m，这个范例不仅展示如何撰写一个 dealloc method，也展示了如何 dealloc 成员变量。

每个 set method 里的三个动作的顺序非常重要。假设你把自己当参数传给一个自己的 method（有点怪，不过确实可能发生）。若你先 release，「然后」才 retain，你会把自己给解构（destruct，相对于建构）！这就是为什么应该要 1) retain 2) release 3) 设值 的原因。

通常我们不会用 C 形式字串来初始化一个变量，因为它不支援 unicode。下一个 NSAutoreleasePool 的例子会用展示正确使用并初始化字串的方式。

这只是处理成员变量内存管理的一种方式，另一种方式是在你的 set methods 里面建立一份拷贝。

当你想用 NSString 或其他 Foundation framework classes 来做更多程序设计工作时，你需要一个更有弹性的系统，也就是使用 Autorelease pools。

当开发 Mac Cocoa 应用程序时，autorelease pool 会自动地帮你设定好。

如果你执行这个程序，你会发现几件事：第一件事，str1 的 retainCount 为 ffffffff。

另一件事，虽然我只有 release str3，整个程序却还是处于完美的内存管理下，原因是第一个常数字串已经自动被加到 autorelease pool 里了。还有一件事，字串是由 stringWithString 产生的。这个 method 会产生一个 NSString class 类型的字串，并自动加进 autorelease pool。

千万记得，要有良好的内存管理，像 [NSString stringWithString: @"String"] 这种 method 使用了 autorelease pool，而 alloc method 如 [[NSString alloc] initWithString: @"String"] 则没有使用 auto release pool。

在 Objective-C 有两种管理内存的方法， 1) retain and release or 2) retain and release/autorelease。

对于每个 retain，一定要对应一个 release 「或」一个 autorelease。

下一个范例会展示我说的这点。

在这个例子里，此 method 是一个 class level method。在对象建立后，在它上面执行 了 autorelease。在 main method 里面，我从未在此对象上执行 release。

这样行得通的原因是：对任何 retain 而言，一定要执行一个 release 或 autorelease。对象的 retainCount 从 1 起跳 ，然后我在上面执行 1 次 autorelease，表示 1 - 1 = 0。当 autorelease pool 被释放时，它会计算所有对象上的 autorelease 执行次数，并且执行相同次数的 [obj release]。

如同注解所说，不把那一行注解掉会造成分段错误（segment fault）。因为对象上已经执行过 autorelease，若再执行 release，在释放 autorelease pool 时会试图执行一个 nil 对象上的 dealloc，但这是不允许的。最后的算式会变为：1 (creation) - 1 (release) - 1 (autorelease) = -1

管理大量暂时对象时，autorelease pool 可以被动态地产生。你需要做的只是建立一个 pool，执行一堆会建立大量动态对象的代码，然后释放这个 pool。你可能会感到好奇，这表示可能同时有超过一个 autorelease pool 存在。

Foundation framework 地位如同 C++ 的 Standard Template Library。不过 Objective-C 是真正的动态识别语言（dynamic types），所以不需要像 C++ 那样肥得可怕的样版（templates）。这个 framework 包含了对象组丶网路丶执行绪，还有更多好东西。

阵列有两种（通常是 Foundation classes 中最资料导向的部分），NSArray 跟 NSMutableArray，顾名思义，mutable（善变的）表示可以被改变，而 NSArray 则不行。这表示你可以制造一个 NSArray 但却不能改变它的长度。

你可以用 Obj, Obj, Obj, ..., nil 为参数执行构造函数来初始化一个阵列，其中 nil 表示结尾符号。

排序（sorting）展示如何用 selector 来排序一个对象，这个 selector 告诉阵列用 NSString 的忽略大小写顺序来排序。如果你的对象有好几个排序方法，你可以使用这个 selector 来选择你想用的方法。

在 print method 里，我使用了 description method。它就像 Java 的 toString，会返回对象的 NSString 表示法。

NSEnumerator 很像 Java 的列举系统。while ( obj = [array objectEnumerator] ) 行得通的理由是 objectEnumerator 会返回最后一个对象的 nil。在 C 里 nil 通常代表 0，也就是 false。改用 ( ( obj = [array objectEnumerator] ) != nil ) 也许更好。

Cateogies

Posing

动态识别

指标计算

弹性消息传递

不是一个过度复杂的 C 衍生语言

可透过 Objective-C++ 与 C++ 结合

不支援命名空间

不支援运算子多载（虽然这常常被视为一个优点，不过正确地使用运算子多载可以降低代码复杂度）

语言里仍然有些讨厌的东西，不过不比 C++ 多。

<a href="http://www.toodarkpark.org/computers/objc/">Object-Oriented Programming and the Objective-C Language</a>

<a href="http://www.gnustep.it/nicola/Tutorials/index.html">GNUstep mini tutorials</a>

<a href="http://www.amazon.com/gp/redirect.html?ie=UTF8&amp;location=http%3A%2F%2Fwww.amazon.com%2FProgramming-Objective-C-Stephen-Kochan%2Fdp%2F0672325861%2Fsr%3D8-1%2Fqid%3D1159892836%2Fref%3Dpd_bbs_1%3Fie%3DUTF8%26s%3Dbooks&amp;tag=tristanshomep-20&amp;linkCode=ur2&amp;camp=1789&amp;creative=9325">Programming in Objective-C</a>

<a href="http://www.amazon.com/gp/redirect.html?ie=UTF8&amp;location=http%3A%2F%2Fwww.amazon.com%2Fexec%2Fobidos%2Ftg%2Fdetail%2F-%2F0596003013%2Fqid%3D1080660707%2Fsr%3D8-1%2Fref%3Dsr_8_xs_ap_i1_xgl14%3Fv%3Dglance%26s%3Dbooks%26n%3D507846&amp;tag=tristanshomep-20&amp;linkCode=ur2&amp;camp=1789&amp;creative=9325">Learning Cocoa with Objective-C</a>

<a href="http://www.amazon.com/gp/redirect.html?ie=UTF8&amp;location=http%3A%2F%2Fwww.amazon.com%2FCocoa-Programming-Mac-OS-2nd%2Fdp%2F0321213149%2Fsr%3D8-2%2Fqid%3D1159892836%2Fref%3Dpd_bbs_2%3Fie%3DUTF8%26s%3Dbooks&amp;tag=tristanshomep-20&amp;linkCode=ur2&amp;camp=1789&amp;creative=9325">Cocoa Programming for Mac OS X</a>

Last modified: April 13, 2004.