Object-C 新手教程

大纲

開始吧
- 下载这篇教学
  - 全部这篇刚開始学习的人指南的原始码都能够由
    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 <stdio.h>

§ int main( int argc, const char *argv[] ) {

§ printf( "hello world/n"
);

§ return
0;

}

- - 输出

hello world

- - 在 Objective-C 中使用 #import 取代 #include
  - Objective-C 的预设扩展名是 .m
创建 classes
- @interface
  - 基于 "Programming in Objective-C," Copyright © 2004 by Sams Publishing
    一书中的范例，并经过同意而刊载。
  - Fraction.h

§ #import <Foundation/NSObject.h>

§ @interface Fraction: NSObject {

§ int
numerator;

§ int
denominator;

§ }

§ -(void) print;

§ -(void) setNumerator: (int) d;

§ -(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
  - 基于 "Programming in Objective-C," Copyright © 2004 by Sams Publishing
    一书中的范例，并经过同意而刊载。
  - Fraction.m

§ #import "Fraction.h"

§ #import <stdio.h>

§ @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

- - Implementation 以 @implementation ClassName 開始，以 @end
    结束。
  - Implement 定义好的 methods 的方式，跟在 interface
    中宣告时非常近似。
- 把它们凑在一起
  - 基于 "Programming in Objective-C," Copyright © 2004 by Sams Publishing
    一书中的范例，并经过同意而刊载。
  - main.m

§ #import <stdio.h>

§ #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] 很easy。它呼叫了 frac 上的 setNumerator method 并传入 1 为參数。
  - 如同每一个 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 <stdio.h>

§ #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）
  - 基于 "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 <stdio.h>

§ #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 <Foundation/NSObject.h>

§ @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 <stdio.h>

§ 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
  - 当你想计算一个对象被 instance 几次时，通常有 class level variables
    以及 class level functions 是件方便的事。
  - ClassA.h

§ #import <Foundation/NSObject.h>

§ 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 <stdio.h>

§ 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 以上才支持。
  - 基于 "Programming in Objective-C," Copyright © 2004 by Sams
    Publishing一书中的范例，并经过同意而刊载。
  - CupWarningException.h

§ #import <Foundation/NSException.h>

§ @interface CupWarningException: NSException

@end

- - CupWarningException.m

§ #import "CupWarningException.h"

§ @implementation CupWarningException

@end

- - CupOverflowException.h

§ #import <Foundation/NSException.h>

§ @interface CupOverflowException: NSException

@end

- - CupOverflowException.m

§ #import "CupOverflowException.h"

§ @implementation CupOverflowException

@end

- - Cup.h

§ #import <Foundation/NSObject.h>

§ @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 <Foundation/NSException.h>

§ #import <Foundation/NSString.h>

§ @implementation Cup

§ -(id) init {

§ self = [super
init];

§ if ( self )
{

§ [self setLevel:
0];

§ }

§ return
self;

§ }

§ -(int) level {

§ return
level;

§ }

§ -(void) setLevel: (int) l {

§ level =
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 <Foundation/NSString.h>

§ #import <Foundation/NSException.h>

§ #import <Foundation/NSAutoreleasePool.h>

§ #import <stdio.h>

§ 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 *。
继承、多型（Inheritance, Polymorphism）以及其它面向对象功能
- id 型别
  - Objective-C 有种叫做 id 的型别，它的运作有时候像是
    void*，只是它却严格规定仅仅能用在对象。Objective-C 与 Java 跟 C++ 不一样，你在呼叫一个对象的 method 时，并不须要知道这个对象的型别。当然这个 method
    一定要存在，这称为 Objective-C 的讯息传递。
  - 基于 "Programming in Objective-C," Copyright © 2004 by Sams
    Publishing一书中的范例，并经过同意而刊载。
  - Fraction.h

§ #import <Foundation/NSObject.h>

§ @interface Fraction: NSObject {

§ int
numerator;

§ int
denominator;

§ }

§ -(Fraction*) initWithNumerator: (int) n denominator: (int)
d;

§ -(void) print;

§ -(void) setNumerator: (int) d;

§ -(void) setDenominator: (int) d;

§ -(void) setNumerator: (int) n andDenominator: (int)
d;

§ -(int) numerator;

§ -(int) denominator;

@end

- - Fraction.m

§ #import "Fraction.h"

§ #import <stdio.h>

§ @implementation Fraction

§ -(Fraction*) initWithNumerator: (int) n denominator: (int) d
{

§ self = [super
init];

§ if ( self )
{

§ [self setNumerator: n
andDenominator: d];

§ }

§ return
self;

§ }

§ -(void) print {

§ printf( "%i / %i",
numerator, denominator );

§ }

§ -(void) setNumerator: (int) n {

§ numerator =
n;

§ }

§ -(void) setDenominator: (int) d {

§ denominator =
d;

§ }

§ -(void) setNumerator: (int) n andDenominator: (int) d
{

§ numerator =
n;

§ denominator =
d;

§ }

§ -(int) denominator {

§ return
denominator;

§ }

§ -(int) numerator {

§ return
numerator;

§ }

@end

- - Complex.h

§ #import <Foundation/NSObject.h>

§ @interface Complex: NSObject {

§ double
real;

§ double imaginary;

§ }

§ -(Complex*) initWithReal: (double) r andImaginary: (double)
i;

§ -(void) setReal: (double) r;

§ -(void) setImaginary: (double) i;

§ -(void) setReal: (double) r andImaginary: (double)
i;

§ -(double) real;

§ -(double) imaginary;

§ -(void) print;

@end

- - Complex.m

§ #import "Complex.h"

§ #import <stdio.h>

§ @implementation Complex

§ -(Complex*) initWithReal: (double) r andImaginary: (double) i
{

§ self = [super
init];

§ if ( self )
{

§ [self setReal: r
andImaginary: i];

§ }

§ return
self;

§ }

§ -(void) setReal: (double) r {

§ real =
r;

§ }

§ -(void) setImaginary: (double) i {

§ imaginary =
i;

§ }

§ -(void) setReal: (double) r andImaginary: (double) i
{

§ real =
r;

§ imaginary =
i;

§ }

§ -(double) real {

§ return
real;

§ }

§ -(double) imaginary {

§ return imaginary;

§ }

§ -(void) print {

§ printf( "%_f + %_fi",
real, imaginary );

§ }

@end

- - main.m

§ #import <stdio.h>

§ #import "Fraction.h"

§ #import "Complex.h"

§ int main( int argc, const char *argv[] ) {

§ // create a new
instance

§ Fraction *frac =
[[Fraction alloc] initWithNumerator: 1 denominator: 10];

§ Complex *comp = [[Complex
alloc] initWithReal: 10 andImaginary: 15];

§ id
number;

§ // print
fraction

§ number =
frac;

§ printf( "The fraction is:
" );

§ [number
print];

§ printf( "/n"
);

§ // print
complex

§ number =
comp;

§ printf( "The complex
number is: " );

§ [number
print];

§ printf( "/n"
);

§ // free
memory

§ [frac
release];

§ [comp
release];

§ return
0;

}

- - output

§ The fraction is: 1 / 10

The complex number is: 10.000000 + 15.000000i

- - 这样的动态链接有显而易见的优点。你不须要知道你呼叫 method 的那个东西是什么型别，假设这个对象对这个讯息有反应，那就会唤起这个
    method。这也不会牵涉到一堆繁琐的转型动作，比方在 Java 里呼叫一个整数对象的 .intValue() 就得先转型，然后才干呼叫这个
    method。
- 继承（Inheritance）
  - 基于 "Programming in Objective-C," Copyright © 2004 by Sams
    Publishing一书中的范例，并经过同意而刊载。
  - Rectangle.h

§ #import <Foundation/NSObject.h>

§ @interface Rectangle: NSObject {

§ int
width;

§ int
height;

§ }

§ -(Rectangle*) initWithWidth: (int) w height: (int)
h;

§ -(void) setWidth: (int) w;

§ -(void) setHeight: (int) h;

§ -(void) setWidth: (int) w height: (int) h;

§ -(int) width;

§ -(int) height;

§ -(void) print;

@end

- - Rectangle.m

§ #import "Rectangle.h"

§ #import <stdio.h>

§ @implementation Rectangle

§ -(Rectangle*) initWithWidth: (int) w height: (int) h
{

§ self = [super
init];

§ if ( self )
{

§ [self setWidth: w height:
h];

§ }

§ return
self;

§ }

§ -(void) setWidth: (int) w {

§ width =
w;

§ }

§ -(void) setHeight: (int) h {

§ height =
h;

§ }

§ -(void) setWidth: (int) w height: (int) h {

§ width =
w;

§ height =
h;

§ }

§ -(int) width {

§ return
width;

§ }

§ -(int) height {

§ return height;

§ }

§ -(void) print {

§ printf( "width = %i,
height = %i", width, height );

§ }

@end

- - Square.h

§ #import "Rectangle.h"

§ @interface Square: Rectangle

§ -(Square*) initWithSize: (int) s;

§ -(void) setSize: (int) s;

§ -(int) size;

@end

- - Square.m

§ #import "Square.h"

§ @implementation Square

§ -(Square*) initWithSize: (int) s {

§ self = [super
init];

§ if ( self )
{

§ [self setSize:
s];

§ }

§ return
self;

§ }

§ -(void) setSize: (int) s {

§ width =
s;

§ height =
s;

§ }

§ -(int) size {

§ return
width;

§ }

§ -(void) setWidth: (int) w {

§ [self setSize:
w];

§ }

§ -(void) setHeight: (int) h {

§ [self setSize:
h];

§ }

@end

- - main.m

§ #import "Square.h"

§ #import "Rectangle.h"

§ #import <stdio.h>

§ int main( int argc, const char *argv[] ) {

§ Rectangle *rec =
[[Rectangle alloc] initWithWidth: 10 height: 20];

§ Square *sq = [[Square
alloc] initWithSize: 15];

§ // print
em

§ printf( "Rectangle: "
);

§ [rec
print];

§ printf( "/n"
);

§ printf( "Square: "
);

§ [sq
print];

§ printf( "/n"
);

§ // update
square

§ [sq setWidth:
20];

§ printf( "Square after
change: " );

§ [sq
print];

§ printf( "/n"
);

§ // free
memory

§ [rec
release];

§ [sq
release];

§ return
0;

}

- - output

§ Rectangle: width = 10, height = 20

§ Square: width = 15, height = 15

Square after change: 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（说明部分採中英并列，由于我认为英文比較传神，中文怎么译都怪）：

-(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一书中的范例，并经过同意而刊载。
  - main.m

§ #import "Square.h"

§ #import "Rectangle.h"

§ #import <stdio.h>

§ int main( int argc, const char *argv[] ) {

§ Rectangle *rec =
[[Rectangle alloc] initWithWidth: 10 height: 20];

§ Square *sq = [[Square
alloc] initWithSize: 15];

§ //
isMemberOfClass

§ // true

§ if ( [sq isMemberOfClass:
[Square class]] == YES ) {

§ printf( "square is a
member of square class/n" );

§ }

§ //
false

§ if ( [sq isMemberOfClass:
[Rectangle class]] == YES ) {

§ printf( "square is a
member of rectangle class/n" );

§ }

§ //
false

§ if ( [sq isMemberOfClass:
[NSObject class]] == YES ) {

§ printf( "square is a
member of object class/n" );

§ }

§ //
isKindOfClass

§ // true

§ if ( [sq isKindOfClass:
[Square class]] == YES ) {

§ printf( "square is a
kind of square class/n" );

§ }

§ //
true

§ if ( [sq isKindOfClass:
[Rectangle class]] == YES ) {

§ printf( "square is a
kind of rectangle class/n" );

§ }

§ //
true

§ if ( [sq isKindOfClass:
[NSObject class]] == YES ) {

§ printf( "square is a
kind of object class/n" );

§ }

§ //
respondsToSelector

§ //
true

§ if ( [sq
respondsToSelector: @selector( setSize: )] == YES ) {

§ printf( "square
responds to setSize: method/n" );

§ }

§ //
false

§ if ( [sq
respondsToSelector: @selector( nonExistant )] == YES ) {

§ printf( "square
responds to nonExistant method/n" );

§ }

§ //
true

§ if ( [Square
respondsToSelector: @selector( alloc )] == YES ) {

§ printf( "square class
responds to alloc method/n" );

§ }

§ //
instancesRespondToSelector

§ //
false

§ if ( [Rectangle
instancesRespondToSelector: @selector( setSize: )] == YES )
{

§ printf( "rectangle
instance responds to setSize: method/n" );

§ }

§ //
true

§ if ( [Square
instancesRespondToSelector: @selector( setSize: )] == YES )
{

§ printf( "square
instance responds to setSize: method/n" );

§ }

§ // free
memory

§ [rec
release];

§ [sq
release];

§ return
0;

}

- - output

§ square is a member of square class

§ square is a kind of square class

§ square is a kind of rectangle class

§ square is a kind of object class

§ square responds to setSize: method

§ square class responds to alloc method

square instance responds to setSize: method

- Categories
  - 当你想要为某个 class 新增 methods，你一般会扩充（extend，即继承）它。然而这不一定是个完美解法，特别是你想要重写一个 class
    的某个功能，但你却没有原始码时。Categories 同意你在现有的 class 增加新功能，但不须要扩充它。Ruby
    语言也有相似的功能。
  - 基于 "Programming in Objective-C," Copyright © 2004 by Sams
    Publishing一书中的范例，并经过同意而刊载。
  - FractionMath.h

§ #import "Fraction.h"

§ @interface Fraction (Math)

§ -(Fraction*) add: (Fraction*) f;

§ -(Fraction*) mul: (Fraction*) f;

§ -(Fraction*) div: (Fraction*) f;

§ -(Fraction*) sub: (Fraction*) f;

@end

- - FractionMath.m

§ #import "FractionMath.h"

§ @implementation Fraction (Math)

§ -(Fraction*) add: (Fraction*) f {

§ return [[Fraction alloc]
initWithNumerator: numerator * [f denominator] +

§ denominator
* [f numerator]

§ denominator:
denominator * [f denominator]];

§ }

§ -(Fraction*) mul: (Fraction*) f {

§ return [[Fraction alloc]
initWithNumerator: numerator * [f numerator]

§ denominator:
denominator * [f denominator]];

§ }

§ -(Fraction*) div: (Fraction*) f {

§ return [[Fraction alloc]
initWithNumerator: numerator * [f denominator]

§ denominator:
denominator * [f numerator]];

§ }

§ -(Fraction*) sub: (Fraction*) f {

§ return [[Fraction alloc]
initWithNumerator: numerator * [f denominator] -

§ denominator
* [f numerator]

§ denominator:
denominator * [f denominator]];

§ }

@end

- - main.m

§ #import <stdio.h>

§ #import "Fraction.h"

§ #import "FractionMath.h"

§ int main( int argc, const char *argv[] ) {

§ // create a new
instance

§ Fraction *frac1 =
[[Fraction alloc] initWithNumerator: 1 denominator: 3];

§ Fraction *frac2 =
[[Fraction alloc] initWithNumerator: 2 denominator: 5];

§ Fraction *frac3 = [frac1
mul: frac2];

§ // print
it

§ [frac1
print];

§ printf( " * "
);

§ [frac2
print];

§ printf( " = "
);

§ [frac3
print];

§ printf( "/n"
);

§ // free
memory

§ [frac1
release];

§ [frac2
release];

§ [frac3
release];

§ return
0;

}

- - output

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)
    档案。下面是此种作法一个简短的范例。
  - MyClass.h

§ #import <Foundation/NSObject.h>

§ @interface MyClass: NSObject

§ -(void) publicMethod;

@end

- - MyClass.m

§ #import "MyClass.h"

§ #import <stdio.h>

§ @implementation MyClass

§ -(void) publicMethod {

§ printf( "public method/n"
);

§ }

§ @end

§ // private methods

§ @interface MyClass (Private)

§ -(void) privateMethod;

§ @end

§ @implementation MyClass (Private)

§ -(void) privateMethod {

§ printf( "private method/n"
);

§ }

@end

- - main.m

§ #import "MyClass.h"

§ int main( int argc, const char *argv[] ) {

§ MyClass *obj = [[MyClass
alloc] init];

§ // this
compiles

§ [obj
publicMethod];

§ // this throws errors when
compiling

§ //[obj
privateMethod];

§ // free
memory

§ [obj
release];

§ return
0;

}

- - output

public method

- Posing
  - Posing 有点像 categories，可是不太一样。它同意你扩充一个
    class，而且全面性地的扮演（pose）这个 super
    class。比如：你有一个扩充 NSArray 的
    NSArrayChild 物件。假设你让 NSArrayChild 扮演 NSArray，则在你的程序代码中全部的 NSArray
    都会自己主动被替代为 NSArrayChild。
  - 基于 "Programming in Objective-C," Copyright © 2004 by Sams
    Publishing一书中的范例，并经过同意而刊载。
  - FractionB.h

§ #import "Fraction.h"

§ @interface FractionB: Fraction

§ -(void) print;

§ @end

- - FractionB.m

§ #import "FractionB.h"

§ #import <stdio.h>

§ @implementation FractionB

§ -(void) print {

§ printf( "(%i/%i)",
numerator, denominator );

§ }

@end

- - main.m

§ #import <stdio.h>

§ #import "Fraction.h"

§ #import "FractionB.h"

§ int main( int argc, const char *argv[] ) {

§ Fraction *frac =
[[Fraction alloc] initWithNumerator: 3 denominator: 10];

§ // print
it

§ printf( "The fraction is:
" );

§ [frac
print];

§ printf( "/n"
);

§ // make FractionB pose as
Fraction

§ [FractionB poseAsClass:
[Fraction class]];

§ Fraction *frac2 =
[[Fraction alloc] initWithNumerator: 3 denominator: 10];

§ // print
it

§ printf( "The fraction is:
" );

§ [frac2
print];

§ printf( "/n"
);

§ // free
memory

§ [frac
release];

§ [frac2
release];

§ return
0;

}

- - output

§ The fraction is: 3/10

The fraction is: (3/10)

- - 这个程序的输出中，第一个 fraction 会输出 3/10，而第二个会输出 (3/10)。这是 FractionB 中实作的方式。
  - poseAsClass 这个 method 是 NSObject 的一部份，它同意 subclass 扮演 superclass。
- Protocols
  - Objective-C 里的 Protocol 与 Java 的
    interface 或是 C++ 的 purely
    virtual class 同样。
  - 基于 "Programming in Objective-C," Copyright © 2004 by Sams
    Publishing一书中的范例，并经过同意而刊载。
  - Printing.h

§ @protocol Printing

§ -(void) print;

@end

- - Fraction.h

§ #import <Foundation/NSObject.h>

§ #import "Printing.h"

§ @interface Fraction: NSObject <Printing, NSCopying>
{

§ int
numerator;

§ int
denominator;

§ }

§ -(Fraction*) initWithNumerator: (int) n denominator: (int)
d;

§ -(void) setNumerator: (int) d;

§ -(void) setDenominator: (int) d;

§ -(void) setNumerator: (int) n andDenominator: (int)
d;

§ -(int) numerator;

§ -(int) denominator;

@end

- - Fraction.m

§ #import "Fraction.h"

§ #import <stdio.h>

§ @implementation Fraction

§ -(Fraction*) initWithNumerator: (int) n denominator: (int) d
{

§ self = [super
init];

§ if ( self )
{

§ [self setNumerator: n
andDenominator: d];

§ }

§ return
self;

§ }

§ -(void) print {

§ printf( "%i/%i",
numerator, denominator );

§ }

§ -(void) setNumerator: (int) n {

§ numerator =
n;

§ }

§ -(void) setDenominator: (int) d {

§ denominator =
d;

§ }

§ -(void) setNumerator: (int) n andDenominator: (int) d
{

§ numerator =
n;

§ denominator =
d;

§ }

§ -(int) denominator {

§ return
denominator;

§ }

§ -(int) numerator {

§ return
numerator;

§ }

§ -(Fraction*) copyWithZone: (NSZone*) zone {

§ return [[Fraction
allocWithZone: zone] initWithNumerator: numerator

§ denominator:
denominator];

§ }

@end

- - Complex.h

§ #import <Foundation/NSObject.h>

§ #import "Printing.h"

§ @interface Complex: NSObject <Printing> {

§ double
real;

§ double
imaginary;

§ }

§ -(Complex*) initWithReal: (double) r andImaginary: (double)
i;

§ -(void) setReal: (double) r;

§ -(void) setImaginary: (double) i;

§ -(void) setReal: (double) r andImaginary: (double)
i;

§ -(double) real;

§ -(double) imaginary;

@end

- - Complex.m

§ #import "Complex.h"

§ #import <stdio.h>

§ @implementation Complex

§ -(Complex*) initWithReal: (double) r andImaginary: (double) i
{

§ self = [super
init];

§ if ( self )
{

§ [self setReal: r
andImaginary: i];

§ }

§ return
self;

§ }

§ -(void) setReal: (double) r {

§ real =
r;

§ }

§ -(void) setImaginary: (double) i {

§ imaginary =
i;

§ }

§ -(void) setReal: (double) r andImaginary: (double) i
{

§ real =
r;

§ imaginary =
i;

§ }

§ -(double) real {

§ return
real;

§ }

§ -(double) imaginary {

§ return
imaginary;

§ }

§ -(void) print {

§ printf( "%_f + %_fi",
real, imaginary );

§ }

@end

- - main.m

§ #import <stdio.h>

§ #import "Fraction.h"

§ #import "Complex.h"

§ int main( int argc, const char *argv[] ) {

§ // create a new
instance

§ Fraction *frac =
[[Fraction alloc] initWithNumerator: 3 denominator: 10];

§ Complex *comp = [[Complex
alloc] initWithReal: 5 andImaginary: 15];

§ id <Printing>
printable;

§ id <NSCopying,
Printing> copyPrintable;

§ // print
it

§ printable =
frac;

§ printf( "The fraction is:
" );

§ [printable
print];

§ printf( "/n"
);

§ // print
complex

§ printable =
comp;

§ printf( "The complex
number is: " );

§ [printable
print];

§ printf( "/n"
);

§ // this compiles because
Fraction comforms to both Printing and NSCopyable

§ copyPrintable =
frac;

§ // this doesn't compile
because Complex only conforms to Printing

§ //copyPrintable =
comp;

§ // test
conformance

§ //
true

§ if ( [frac
conformsToProtocol: @protocol( NSCopying )] == YES ) {

§ printf( "Fraction
conforms to NSCopying/n" );

§ }

§ //
false

§ if ( [comp
conformsToProtocol: @protocol( NSCopying )] == YES ) {

§ printf( "Complex
conforms to NSCopying/n" );

§ }

§ // free
memory

§ [frac
release];

§ [comp
release];

§ return
0;

}

- - output

§ The fraction is: 3/10

§ The complex number is: 5.000000 + 15.000000i

Fraction conforms to NSCopying

- - protocol 的宣告十分简单，基本上就是 @protocol ProtocolName (methods you must implement)
    @end。
  - 要遵从（conform）某个 protocol，将要遵从的 protocols 放在 <>
    里面，并以逗点分隔。如：@interface SomeClass <Protocol1,
    Protocol2, Protocol3>
  - protocol 要求实作的 methods 不须要放在 header 档里面的 methods 列表中。如你所见，Complex.h 档案里没有 -(void) print 的宣告，却还是要实作它，由于它（Complex
    class）遵从了这个 protocol。
  - Objective-C 的接口系统有一个独一无二的观念是怎样指定一个型别。比起 C++ 或 Java 的指定方式，如：Printing *someVar = ( Printing * ) frac; 你能够使用 id 型别加上 protocol：id
    <Printing> var = frac;。这让你能够动态地指定一个要求多个 protocol
    的型别，却从头到尾仅仅用了一个变数。如：<Printing, NSCopying> var =
    frac;
  - 就像使用@selector 来測试对象的继承关系，你能够使用 @protocol
    来測试对象是否遵从接口。假设对象遵从这个接口，[object conformsToProtocol:
    @protocol( SomeProtocol )] 会回传一个 YES 型态的 BOOL 对象。相同地，对 class 而言也能如法炮制 [SomeClass conformsToProtocol: @protocol( SomeProtocol
    )]。
内存管理
- 到眼下为止我都刻意避开 Objective-C 的内存管理议题。你能够呼叫对象上的
  dealloc，可是若对象里包括其它对象的指针的话，要怎么办呢？要释放那些对象所占领的内存也是一个必须关注的问题。当你使用 Foundation framework 建立 classes
  时，它怎样管理内存？这些稍后我们都会解释。
  - 注意：之前全部的范例都有正确的内存管理，以免你混淆。
- Retain and Release（保留与释放）
  - Retain 以及 release 是两个继承自 NSObject 的对象都会有的 methods。每一个对象都有一个内部计数器，能够用来追踪对象的 reference
    个数。假设对象有 3 个 reference
    时，不须要 dealloc 自己。可是假设计数器值到达 0
    时，对象就得 dealloc 自己。[object
    retain] 会将计数器值加 1（值从 1
    開始），[object release] 则将计数器值减
    1。假设呼叫 [object release] 导致计数器到达
    0，就会自己主动 dealloc。
  - Fraction.m

§ ...

§ -(void) dealloc {

§ printf( "Deallocing
fraction/n" );

§ [super
dealloc];

§ }

...

§ #import "Fraction.h"

§ #import <stdio.h>

§ int main( int argc, const char *argv[] ) {

§ Fraction *frac1 =
[[Fraction alloc] init];

§ Fraction *frac2 =
[[Fraction alloc] init];

§ // print current
counts

§ printf( "Fraction 1 retain
count: %i/n", [frac1 retainCount] );

§ printf( "Fraction 2 retain
count: %i/n", [frac2 retainCount] );

§ // increment
them

§ [frac1 retain]; //
2

§ [frac1 retain]; //
3

§ [frac2 retain]; //
2

§ // print current
counts

§ printf( "Fraction 1 retain
count: %i/n", [frac1 retainCount] );

§ printf( "Fraction 2 retain
count: %i/n", [frac2 retainCount] );

§ // decrement

§ [frac1 release]; //
2

§ [frac2 release]; //
1

§ // print current
counts

§ printf( "Fraction 1 retain
count: %i/n", [frac1 retainCount] );

§ printf( "Fraction 2 retain
count: %i/n", [frac2 retainCount] );

§ // release them until they
dealloc themselves

§ [frac1 release]; //
1

§ [frac1 release]; //
0

§ [frac2 release]; //
0

}

- - output

§ Fraction 1 retain count: 1

§ Fraction 2 retain count: 1

§ Fraction 1 retain count: 3

§ Fraction 2 retain count: 2

§ Fraction 1 retain count: 2

§ Fraction 2 retain count: 1

§ Deallocing fraction

Deallocing fraction

- - Retain call 添加计数器值，而 release call 降低它。你能够呼叫 [obj retainCount]
    来取得计数器的 int 值。当当 retainCount
    到达 0，两个对象都会 dealloc
    自己，所以能够看到印出了两个 "Deallocing fraction"。
- Dealloc
  - 当你的对象包括其它对象时，就得在 dealloc 自己时释放它们。Objective-C
    的一个长处是你能够传递讯息给 nil，所以不须要经过一堆防错測试来释放一个对象。
  - 基于 "Programming in Objective-C," Copyright © 2004 by Sams
    Publishing一书中的范例，并经过同意而刊载。
  - AddressCard.h

§ #import <Foundation/NSObject.h>

§ #import <Foundation/NSString.h>

§ @interface AddressCard: NSObject {

§ NSString *first;

§ NSString
*last;

§ NSString
*email;

§ }

§ -(AddressCard*) initWithFirst: (NSString*) f

§ last:
(NSString*) l

§ email:
(NSString*) e;

§ -(NSString*) first;

§ -(NSString*) last;

§ -(NSString*) email;

§ -(void) setFirst: (NSString*) f;

§ -(void) setLast: (NSString*) l;

§ -(void) setEmail: (NSString*) e;

§ -(void) setFirst: (NSString*) f

§ last: (NSString*)
l

§ email: (NSString*)
e;

§ -(void) setFirst: (NSString*) f last: (NSString*)
l;

§ -(void) print;

@end

- - AddressCard.m

§ #import "AddressCard.h"

§ #import <stdio.h>

§ @implementation AddressCard

§ -(AddressCard*) initWithFirst: (NSString*) f

§ last:
(NSString*) l

§ email:
(NSString*) e {

§ self = [super
init];

§ if ( self )
{

§ [self setFirst: f
last: l email: e];

§ }

§ return
self;

§ }

§ -(NSString*) first {

§ return
first;

§ }

§ -(NSString*) last {

§ return
last;

§ }

§ -(NSString*) email {

§ return
email;

§ }

§ -(void) setFirst: (NSString*) f {

§ [f
retain];

§ [first
release];

§ first =
f;

§ }

§ -(void) setLast: (NSString*) l {

§ [l
retain];

§ [last
release];

§ last =
l;

§ }

§ -(void) setEmail: (NSString*) e {

§ [e
retain];

§ [email
release];

§ email =
e;

§ }

§ -(void) setFirst: (NSString*) f

§ last: (NSString*)
l

§ email: (NSString*) e
{

§ [self setFirst:
f];

§ [self setLast:
l];

§ [self setEmail:
e];

§ }

§ -(void) setFirst: (NSString*) f last: (NSString*) l
{

§ [self setFirst:
f];

§ [self setLast:
l];

§ }

§ -(void) print {

§ printf( "%s %s
<%s>", [first cString],

§ [last
cString],

§ [email cString]
);

§ }

§ -(void) dealloc {

§ [first
release];

§ [last
release];

§ [email
release];

§ [super
dealloc];

§ }

@end

- - main.m

§ #import "AddressCard.h"

§ #import <Foundation/NSString.h>

§ #import <stdio.h>

§ int main( int argc, const char *argv[] ) {

§ NSString *first
=[[NSString alloc] initWithCString: "Tom"];

§ NSString *last =
[[NSString alloc] initWithCString: "Jones"];

§ NSString *email =
[[NSString alloc] initWithCString: "tom@jones.com"];

§ AddressCard *tom =
[[AddressCard alloc] initWithFirst: first

§ last:
last

§ email:
email];

§ // we're done with the
strings, so we must dealloc them

§ [first
release];

§ [last
release];

§ [email
release];

§ // print to show the
retain count

§ printf( "Retain count:
%i/n", [[tom first] retainCount] );

§ [tom
print];

§ printf( "/n"
);

§ // free
memory

§ [tom
release];

§ return
0;

}

- - output

§ Retain count: 1

Tom Jones <tom@jones.com>

- - 如 AddressCard.m，这个范例不仅展示怎样撰写一个 dealloc
    method，也展示了怎样 dealloc 成员变量。
  - 每一个 set method 里的三个动作的顺序很重要。如果你把自己当參数传给一个自己的
    method（有点怪，只是确实可能发生）。若你先 release，「然后」才 retain，你会把自己给解构（destruct，相对于建构）！这就是为什么应该要 1) retain 2)
    release 3) 设值的原因。
  - 通常我们不会用 C 形式字符串来初始化一个变量，由于它不支持
    unicode。下一个 NSAutoreleasePool
    的样例会用展示正确使用并初始化字符串的方式。
  - 这仅仅是处理成员变量内存管理的一种方式，还有一种方式是在你的 set methods 里面建立一份拷贝。
- Autorelease Pool
  - 当你想用 NSString 或其它 Foundation framework classes
    来做很多其它程序设计工作时，你须要一个更有弹性的系统，也就是使用 Autorelease
    pools。
  - 当开发 Mac Cocoa 应用程序时，autorelease pool
    会自己主动地帮你设定好。
  - 基于 "Programming in Objective-C," Copyright © 2004 by Sams
    Publishing一书中的范例，并经过同意而刊载。
  - main.m

§ #import <Foundation/NSString.h>

§ #import <Foundation/NSAutoreleasePool.h>

§ #import <stdio.h>

§ int main( int argc, const char *argv[] ) {

§ NSAutoreleasePool *pool =
[[NSAutoreleasePool alloc] init];

§ NSString *str1 =
@"constant string";

§ NSString *str2 = [NSString
stringWithString: @"string managed by the pool"];

§ NSString *str3 =
[[NSString alloc] initWithString: @"self managed string"];

§ // print the
strings

§ printf( "%s retain count:
%x/n", [str1 cString], [str1 retainCount] );

§ printf( "%s retain count:
%x/n", [str2 cString], [str2 retainCount] );

§ printf( "%s retain count:
%x/n", [str3 cString], [str3 retainCount] );

§ // free
memory

§ [str3
release];

§ // free
pool

§ [pool
release];

§ return
0;

}

- - output

§ constant string retain count: ffffffff

§ string managed by the pool retain count: 1

self managed string retain count: 1

- - 假设你运行这个程序，你会发现几件事：第一件事，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。
  - 下一个范例会展示我说的这点。
  - 基于 "Programming in Objective-C," Copyright © 2004 by Sams
    Publishing一书中的范例，并经过同意而刊载。
  - Fraction.h

§ ...

§ +(Fraction*) fractionWithNumerator: (int) n denominator: (int)
d;

§ ...

- - Fraction.m

§ ...

§ +(Fraction*) fractionWithNumerator: (int) n denominator: (int) d
{

§ Fraction *ret = [[Fraction
alloc] initWithNumerator: n denominator: d];

§ [ret
autorelease];

§ return
ret;

§ }

...

- - main.m

§ #import <Foundation/NSAutoreleasePool.h>

§ #import "Fraction.h"

§ #import <stdio.h>

§ int main( int argc, const char *argv[] ) {

§ NSAutoreleasePool *pool =
[[NSAutoreleasePool alloc] init];

§ Fraction *frac1 =
[Fraction fractionWithNumerator: 2 denominator: 5];

§ Fraction *frac2 =
[Fraction fractionWithNumerator: 1 denominator: 3];

§ // print frac
1

§ printf( "Fraction 1: "
);

§ [frac1
print];

§ printf( "/n"
);

§ // print frac
2

§ printf( "Fraction 2: "
);

§ [frac2
print];

§ printf( "/n"
);

§ // this causes a
segmentation fault

§ //[frac1
release];

§ // release the pool and
all objects in it

§ [pool
release];

§ return
0;

}

- - output

§ Fraction 1: 2/5

Fraction 2: 1/3

- - 在这个样例里，此 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 classes
- Foundation framework 地位如同 C++ 的 Standard Template
  Library。只是 Objective-C 是真正的动态识别语言（dynamic types），所以不须要像 C++
  那样肥得可怕的样版（templates）。这个
  framework 包括了对象组、网络、线程，还有很多其它好东西。
- NSArray
  - 基于 "Programming in Objective-C," Copyright © 2004 by Sams
    Publishing一书中的范例，并经过同意而刊载。
  - main.m

§ #import <Foundation/NSArray.h>

§ #import <Foundation/NSString.h>

§ #import <Foundation/NSAutoreleasePool.h>

§ #import <Foundation/NSEnumerator.h>

§ #import <stdio.h>

§ void print( NSArray *array ) {

§ NSEnumerator *enumerator =
[array objectEnumerator];

§ id
obj;

§ while ( obj = [enumerator
nextObject] ) {

§ printf( "%s/n", [[obj
description] cString] );

§ }

§ int main( int argc, const char *argv[] ) {

§ NSAutoreleasePool *pool =
[[NSAutoreleasePool alloc] init];

§ NSArray *arr = [[NSArray
alloc] initWithObjects:

§ @"Me",
@"Myself", @"I", nil];

§ NSMutableArray *mutable =
[[NSMutableArray alloc] init];

§ // enumerate over
items

§ printf( "----static
array/n" );

§ print( arr
);

§ // add
stuff

§ [mutable addObject:
@"One"];

§ [mutable addObject:
@"Two"];

§ [mutable
addObjectsFromArray: arr];

§ [mutable addObject:
@"Three"];

§ // print
em

§ printf( "----mutable
array/n" );

§ print( mutable
);

§ // sort then
print

§ printf( "----sorted
mutable array/n" );

§ [mutable
sortUsingSelector: @selector( caseInsensitiveCompare: )];

§ print( mutable
);

§ // free
memory

§ [arr
release];

§ [mutable
release];

§ [pool
release];

§ return
0;

}

- - output

§ ----static array

§ Me

§ Myself

§ I

§ ----mutable array

§ One

§ Two

§ Me

§ Myself

§ I

§ Three

§ ----sorted mutable array

§ I

§ Me

§ Myself

§ One

§ Three

Two

- - 数组有两种（一般是 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 )
    或许更好。
- NSDictionary
  - 基于 "Programming in Objective-C," Copyright © 2004 by Sams
    Publishing一书中的范例，并经过同意而刊载。
  - main.m

§ #import <Foundation/NSString.h>

§ #import <Foundation/NSAutoreleasePool.h>

§ #import <Foundation/NSDictionary.h>

§ #import <Foundation/NSEnumerator.h>

§ #import <Foundation/Foundation.h<

§ #import <stdio.h>

§ void print( NSDictionary *map ) {

§ NSEnumerator *enumerator =
[map keyEnumerator];

§ id
key;

§ while ( key = [enumerator
nextObject] ) {

§ printf( "%s =>
%s/n",

§ [[key description]
cString],

§ [[[map
objectForKey: key] description] cString] );

§ }

§ int main( int argc, const char *argv[] ) {

§ NSAutoreleasePool *pool =
[[NSAutoreleasePool alloc] init];

§ NSDictionary *dictionary =
[[NSDictionary alloc] initWithObjectsAndKeys:

§ @"one", [NSNumber
numberWithInt: 1],

§ @"two", [NSNumber
numberWithInt: 2],

§ @"three", [NSNumber
numberWithInt: 3],

§ nil];

§ NSMutableDictionary
*mutable = [[NSMutableDictionary alloc] init];

§ // print
dictionary

§ printf( "----static
dictionary/n" );

§ print( dictionary
);

§ // add
objects

§ [mutable setObject: @"Tom"
forKey: @"tom@jones.com"];

§ [mutable setObject: @"Bob"
forKey: @"bob@dole.com" ];

§ // print mutable
dictionary

§ printf( "----mutable
dictionary/n" );

§ print( mutable
);

§ // free memory

§ [dictionary
release];

§ [mutable
release];

§ [pool
release];

§ return
0;

}

- - output

§ ----static dictionary

§ 1 => one

§ 2 => two

§ 3 => three

§ ----mutable dictionary

§ bob@dole.com => Bob

tom@jones.com => Tom

长处与缺点
- 长处
  - Cateogies
  - Posing
  - 动态识别
  - 指标计算
  - 弹性讯息传递
  - 不是一个过度复杂的 C 衍生语言
  - 可透过 Objective-C++ 与 C++ 结合
- 缺点
  - 不支持命名空间
  - 不支持运算符多载（尽管这经常被视为一个长处，只是正确地使用运算符多载能够减少程序代码复杂度）
  - 语言里仍然有些讨厌的东西，只是不比 C++ 多。
很多其它信息

Last modified: April 13, 2004.
中文翻译：William Shih
(xamous)，January 7, 2005

秒客网

Object-C 新手教程

相关文章