|
|
51CTO旗下网站
|
|
移动端

Objective-C代码学习大纲

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

作者:佚名来源:otierney|2011-05-11 14:06

所有这篇初学者指南的塬始码都可以由 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 
  2.  
  3. #import 
  4.  
  5. int main( int argc, const char *argv[] ) { 
  6.  
  7. printf( "hello world\n" ); 
  8.  
  9. return 0; 
  10.  
  11.  

输出

helloworld

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

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

创建classes

@interface

  1.   
  2.   
  3. Fraction.h  
  4.   
  5. #import  
  6.   
  7. @interface Fraction: NSObject {  
  8.   
  9. int numerator;  
  10.   
  11. int denominator;  
  12.   
  13. }  
  14.   
  15. -(void) print;  
  16.   
  17. -(void) setNumerator: (int) n;  
  18.   
  19. -(void) setDenominator: (int) d;  
  20.   
  21. -(int) numerator;  
  22.   
  23. -(int) denominator;  
  24.   
  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 
  2.  
  3. #import "Fraction.h" 
  4.  
  5. #import 
  6.  
  7. @implementation Fraction 
  8.  
  9. -(void) print { 
  10.  
  11. printf( "%i/%i", numerator, denominator ); 
  12.  
  13.  
  14. -(void) setNumerator: (int) n { 
  15.  
  16. nnumerator = n; 
  17.  
  18.  
  19. -(void) setDenominator: (int) d { 
  20.  
  21. ddenominator = d; 
  22.  
  23.  
  24. -(int) denominator { 
  25.  
  26. return denominator; 
  27.  
  28.  
  29. -(int) numerator { 
  30.  
  31. return numerator; 
  32.  
  33.  
  34. @end 

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

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

把它们凑在一起

  1. main.m 
  2.  
  3. #import 
  4.  
  5. #import "Fraction.h" 
  6.  
  7. int main( int argc, const char *argv[] ) { 
  8.  
  9. // create a new instance 
  10.  
  11. Fraction *frac = [[Fraction alloc] init]; 
  12.  
  13. // set the values 
  14.  
  15. [frac setNumerator: 1]; 
  16.  
  17. [frac setDenominator: 3]; 
  18.  
  19. // print it 
  20.  
  21. printf( "The fraction is: " ); 
  22.  
  23. [frac print]; 
  24.  
  25. printf( "\n" ); 
  26.  
  27. // free memory 
  28.  
  29. [frac release]; 
  30.  
  31. return 0; 
  32.  

output

  1. The fraction is: 1/3 
  2.  
  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 版本。

  1. Fraction.h 
  2.  
  3. ... 
  4.  
  5. -(void) setNumerator: (int) n andDenominator: (int) d; 
  6.  
  7. ... 
  8.  
  9. Fraction.m 
  10.  
  11. ... 
  12.  
  13. -(void) setNumerator: (int) n andDenominator: (int) d { 
  14.  
  15. nnumerator = n; 
  16.  
  17. ddenominator = d; 
  18.  
  19.  
  20. ... 
  21.  
  22. main.m 
  23.  
  24. #import 
  25.  
  26. #import "Fraction.h" 
  27.  
  28. int main( int argc, const char *argv[] ) { 
  29.  
  30. // create a new instance 
  31.  
  32. Fraction *frac = [[Fraction alloc] init]; 
  33.  
  34. Fraction *frac2 = [[Fraction alloc] init]; 
  35.  
  36. // set the values 
  37.  
  38. [frac setNumerator: 1]; 
  39.  
  40. [frac setDenominator: 3]; 
  41.  
  42. // combined set 
  43.  
  44. [frac2 setNumerator: 1 andDenominator: 5]; 
  45.  
  46. // print it 
  47.  
  48. printf( "The fraction is: " ); 
  49.  
  50. [frac print]; 
  51.  
  52. printf( "\n" ); 
  53.  
  54. // print it 
  55.  
  56. printf( "Fraction 2 is: " ); 
  57.  
  58. [frac2 print]; 
  59.  
  60. printf( "\n" ); 
  61.  
  62. // free memory 
  63.  
  64. [frac release]; 
  65.  
  66. [frac2 release]; 
  67.  
  68. return 0; 
  69.  

output

  1. The fraction is: 1/3 
  2.  
  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)

  1. Fraction.h 
  2.  
  3. ... 
  4.  
  5. -(Fraction*) initWithNumerator: (int) n denominator: (int) d; 
  6.  
  7. ... 
  8.  
  9. Fraction.m 
  10.  
  11. ... 
  12.  
  13. -(Fraction*) initWithNumerator: (int) n denominator: (int) d { 
  14.  
  15. self = [super init]; 
  16.  
  17. if ( self ) { 
  18.  
  19. [self setNumerator: n andDenominator: d]; 
  20.  
  21.  
  22. return self; 
  23.  
  24.  
  25. ... 
  26.  
  27. main.m 
  28.  
  29. #import 
  30.  
  31. #import "Fraction.h" 
  32.  
  33. int main( int argc, const char *argv[] ) { 
  34.  
  35. // create a new instance 
  36.  
  37. Fraction *frac = [[Fraction alloc] init]; 
  38.  
  39. Fraction *frac2 = [[Fraction alloc] init]; 
  40.  
  41. Fraction *frac3 = [[Fraction alloc] initWithNumerator: 3 denominator: 10]; 
  42.  
  43. // set the values 
  44.  
  45. [frac setNumerator: 1]; 
  46.  
  47. [frac setDenominator: 3]; 
  48.  
  49. // combined set 
  50.  
  51. [frac2 setNumerator: 1 andDenominator: 5]; 
  52.  
  53. // print it 
  54.  
  55. printf( "The fraction is: " ); 
  56.  
  57. [frac print]; 
  58.  
  59. printf( "\n" ); 
  60.  
  61. printf( "Fraction 2 is: " ); 
  62.  
  63. [frac2 print]; 
  64.  
  65. printf( "\n" ); 
  66.  
  67. printf( "Fraction 3 is: " ); 
  68.  
  69. [frac3 print]; 
  70.  
  71. printf( "\n" ); 
  72.  
  73. // free memory 
  74.  
  75. [frac release]; 
  76.  
  77. [frac2 release]; 
  78.  
  79. [frac3 release]; 
  80.  
  81. return 0; 
  82.  

output

  1. The fraction is: 1/3 
  2.  
  3. Fraction 2 is: 1/5 
  4.  
  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)的方式。

  1. Access.h 
  2.  
  3. #import 
  4.  
  5. @interface Access: NSObject { 
  6.  
  7. @public 
  8.  
  9. int publicVar; 
  10.  
  11. @private 
  12.  
  13. int privateVar; 
  14.  
  15. int privateVar2; 
  16.  
  17. @protected 
  18.  
  19. int protectedVar; 
  20.  
  21.  
  22. @end 
  23.  
  24. Access.m 
  25.  
  26. #import "Access.h" 
  27.  
  28. @implementation Access 
  29.  
  30. @end 
  31.  
  32. main.m 
  33.  
  34. #import "Access.h" 
  35.  
  36. #import 
  37.  
  38. int main( int argc, const char *argv[] ) { 
  39.  
  40. Access *a = [[Access alloc] init]; 
  41.  
  42. // works 
  43.  
  44. a->publicVar = 5
  45.  
  46. printf( "public var: %i\n", a->publicVar ); 
  47.  
  48. // doesn't compile 
  49.  
  50. //a->privateVar = 10
  51.  
  52. //printf( "private var: %i\n", a->privateVar ); 
  53.  
  54. [a release]; 
  55.  
  56. return 0; 
  57.  

output

  1. public var: 5 

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

Class level access

  1. ClassA.h 
  2.  
  3. #import 
  4.  
  5. static int count; 
  6.  
  7. @interface ClassA: NSObject 
  8.  
  9. +(int) initCount; 
  10.  
  11. +(void) initialize; 
  12.  
  13. @end 
  14.  
  15. ClassA.m 
  16.  
  17. #import "ClassA.h" 
  18.  
  19. @implementation ClassA 
  20.  
  21. -(id) init { 
  22.  
  23. self = [super init]; 
  24.  
  25. count++; 
  26.  
  27. return self; 
  28.  
  29.  
  30. +(int) initCount { 
  31.  
  32. return count; 
  33.  
  34.  
  35. +(void) initialize { 
  36.  
  37. count = 0
  38.  
  39.  
  40. @end 
  41.  
  42. main.m 
  43.  
  44. #import "ClassA.h" 
  45.  
  46. #import 
  47.  
  48. int main( int argc, const char *argv[] ) { 
  49.  
  50. ClassA *c1 = [[ClassA alloc] init]; 
  51.  
  52. ClassA *c2 = [[ClassA alloc] init]; 
  53.  
  54. // print count 
  55.  
  56. printf( "ClassA count: %i\n", [ClassA initCount] ); 
  57.  
  58. ClassA *c3 = [[ClassA alloc] init]; 
  59.  
  60. // print count again 
  61.  
  62. printf( "ClassA count: %i\n", [ClassA initCount] ); 
  63.  
  64. [c1 release]; 
  65.  
  66. [c2 release]; 
  67.  
  68. [c3 release]; 
  69.  
  70. return 0; 
  71.  

output

  1. ClassA count: 2 
  2.  
  3. 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 以上才支援。

  1. CupWarningException.h 
  2.  
  3. #import 
  4.  
  5. @interface CupWarningException: NSException 
  6.  
  7. @end 
  8.  
  9. CupWarningException.m 
  10.  
  11. #import "CupWarningException.h" 
  12.  
  13. @implementation CupWarningException 
  14.  
  15. @end 
  16.  
  17. CupOverflowException.h 
  18.  
  19. #import 
  20.  
  21. @interface CupOverflowException: NSException 
  22.  
  23. @end 
  24.  
  25. CupOverflowException.m 
  26.  
  27. #import "CupOverflowException.h" 
  28.  
  29. @implementation CupOverflowException 
  30.  
  31. @end 
  32.  
  33. Cup.h 
  34.  
  35. #import 
  36.  
  37. @interface Cup: NSObject { 
  38.  
  39. int level; 
  40.  
  41.  
  42. -(int) level; 
  43.  
  44. -(void) setLevel: (int) l; 
  45.  
  46. -(void) fill; 
  47.  
  48. -(void) empty; 
  49.  
  50. -(void) print; 
  51.  
  52. @end 
  53.  
  54. Cup.m 
  55.  
  56. #import "Cup.h" 
  57.  
  58. #import "CupOverflowException.h" 
  59.  
  60. #import "CupWarningException.h" 
  61.  
  62. #import 
  63.  
  64. #import 
  65.  
  66. @implementation Cup 
  67.  
  68. -(id) init { 
  69.  
  70. self = [super init]; 
  71.  
  72. if ( self ) { 
  73.  
  74. [self setLevel: 0]; 
  75.  
  76.  
  77. return self; 
  78.  
  79.  
  80. -(int) level { 
  81.  
  82. return level; 
  83.  
  84.  
  85. -(void) setLevel: (int) l { 
  86.  
  87. llevel = l; 
  88.  
  89. if ( level > 100 ) { 
  90.  
  91. // throw overflow 
  92.  
  93. NSException *e = [CupOverflowException 
  94.  
  95. exceptionWithName: @"CupOverflowException" 
  96.  
  97. reason: @"The level is above 100" 
  98.  
  99. userInfo: nil]; 
  100.  
  101. @throw e; 
  102.  
  103. } else if ( level >= 50 ) { 
  104.  
  105. // throw warning 
  106.  
  107. NSException *e = [CupWarningException 
  108.  
  109. exceptionWithName: @"CupWarningException" 
  110.  
  111. reason: @"The level is above or at 50" 
  112.  
  113. userInfo: nil]; 
  114.  
  115. @throw e; 
  116.  
  117. } else if ( level < 0 ) { 
  118.  
  119. // throw exception 
  120.  
  121. NSException *e = [NSException 
  122.  
  123. exceptionWithName: @"CupUnderflowException" 
  124.  
  125. reason: @"The level is below 0" 
  126.  
  127. userInfo: nil]; 
  128.  
  129. @throw e; 
  130.  
  131.  
  132.  
  133. -(void) fill { 
  134.  
  135. [self setLevel: level + 10]; 
  136.  
  137.  
  138. -(void) empty { 
  139.  
  140. [self setLevel: level - 10]; 
  141.  
  142.  
  143. -(void) print { 
  144.  
  145. printf( "Cup level is: %i\n", level ); 
  146.  
  147.  
  148. @end 
  149.  
  150. main.m 
  151.  
  152. #import "Cup.h" 
  153.  
  154. #import "CupOverflowException.h" 
  155.  
  156. #import "CupWarningException.h" 
  157.  
  158. #import 
  159.  
  160. #import 
  161.  
  162. #import 
  163.  
  164. #import 
  165.  
  166. int main( int argc, const char *argv[] ) { 
  167.  
  168. NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init]; 
  169.  
  170. Cup *cup = [[Cup alloc] init]; 
  171.  
  172. int i; 
  173.  
  174. // this will work 
  175.  
  176. for ( i = 0; i < 4; i++ ) { 
  177.  
  178. [cup fill]; 
  179.  
  180. [cup print]; 
  181.  
  182.  
  183. // this will throw exceptions 
  184.  
  185. for ( i = 0; i < 7; i++ ) { 
  186.  
  187. @try { 
  188.  
  189. [cup fill]; 
  190.  
  191. } @catch ( CupWarningException *e ) { 
  192.  
  193. printf( "%s: ", [[e name] cString] ); 
  194.  
  195. } @catch ( CupOverflowException *e ) { 
  196.  
  197. printf( "%s: ", [[e name] cString] ); 
  198.  
  199. } @finally { 
  200.  
  201. [cup print]; 
  202.  
  203.  
  204.  
  205. // throw a generic exception 
  206.  
  207. @try { 
  208.  
  209. [cup setLevel: -1]; 
  210.  
  211. } @catch ( NSException *e ) { 
  212.  
  213. printf( "%s: %s\n", [[e name] cString], [[e reason] cString] ); 
  214.  
  215.  
  216. // free memory 
  217.  
  218. [cup release]; 
  219.  
  220. [pool release]; 
  221.  

output

  1. Cup level is: 10 
  2.  
  3. Cup level is: 20 
  4.  
  5. Cup level is: 30 
  6.  
  7. Cup level is: 40 
  8.  
  9. CupWarningException: Cup level is: 50 
  10.  
  11. CupWarningException: Cup level is: 60 
  12.  
  13. CupWarningException: Cup level is: 70 
  14.  
  15. CupWarningException: Cup level is: 80 
  16.  
  17. CupWarningException: Cup level is: 90 
  18.  
  19. CupWarningException: Cup level is: 100 
  20.  
  21. CupOverflowException: Cup level is: 110 
  22.  
  23. 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 的讯息传递。

  1. Fraction.h 
  2.  
  3. #import 
  4.  
  5. @interface Fraction: NSObject { 
  6.  
  7. int numerator; 
  8.  
  9. int denominator; 
  10.  
  11.  
  12. -(Fraction*) initWithNumerator: (int) n denominator: (int) d; 
  13.  
  14. -(void) print; 
  15.  
  16. -(void) setNumerator: (int) d; 
  17.  
  18. -(void) setDenominator: (int) d; 
  19.  
  20. -(void) setNumerator: (int) n andDenominator: (int) d; 
  21.  
  22. -(int) numerator; 
  23.  
  24. -(int) denominator; 
  25.  
  26. @end 
  27.  
  28. Fraction.m 
  29.  
  30. #import "Fraction.h" 
  31.  
  32. #import 
  33.  
  34. @implementation Fraction 
  35.  
  36. -(Fraction*) initWithNumerator: (int) n denominator: (int) d { 
  37.  
  38. self = [super init]; 
  39.  
  40. if ( self ) { 
  41.  
  42. [self setNumerator: n andDenominator: d]; 
  43.  
  44.  
  45. return self; 
  46.  
  47.  
  48. -(void) print { 
  49.  
  50. printf( "%i / %i", numerator, denominator ); 
  51.  
  52.  
  53. -(void) setNumerator: (int) n { 
  54.  
  55. nnumerator = n; 
  56.  
  57.  
  58. -(void) setDenominator: (int) d { 
  59.  
  60. ddenominator = d; 
  61.  
  62.  
  63. -(void) setNumerator: (int) n andDenominator: (int) d { 
  64.  
  65. nnumerator = n; 
  66.  
  67. ddenominator = d; 
  68.  
  69.  
  70. -(int) denominator { 
  71.  
  72. return denominator; 
  73.  
  74.  
  75. -(int) numerator { 
  76.  
  77. return numerator; 
  78.  
  79.  
  80. @end 
  81.  
  82. Complex.h 
  83.  
  84. #import 
  85.  
  86. @interface Complex: NSObject { 
  87.  
  88. double real; 
  89.  
  90. double imaginary; 
  91.  
  92.  
  93. -(Complex*) initWithReal: (double) r andImaginary: (double) i; 
  94.  
  95. -(void) setReal: (double) r; 
  96.  
  97. -(void) setImaginary: (double) i; 
  98.  
  99. -(void) setReal: (double) r andImaginary: (double) i; 
  100.  
  101. -(double) real; 
  102.  
  103. -(double) imaginary; 
  104.  
  105. -(void) print; 
  106.  
  107. @end 
  108.  
  109. Complex.m 
  110.  
  111. #import "Complex.h" 
  112.  
  113. #import 
  114.  
  115. @implementation Complex 
  116.  
  117. -(Complex*) initWithReal: (double) r andImaginary: (double) i { 
  118.  
  119. self = [super init]; 
  120.  
  121. if ( self ) { 
  122.  
  123. [self setReal: r andImaginary: i]; 
  124.  
  125.  
  126. return self; 
  127.  
  128.  
  129. -(void) setReal: (double) r { 
  130.  
  131. rreal = r; 
  132.  
  133.  
  134. -(void) setImaginary: (double) i { 
  135.  
  136. iimaginary = i; 
  137.  
  138.  
  139. -(void) setReal: (double) r andImaginary: (double) i { 
  140.  
  141. rreal = r; 
  142.  
  143. iimaginary = i; 
  144.  
  145.  
  146. -(double) real { 
  147.  
  148. return real; 
  149.  
  150.  
  151. -(double) imaginary { 
  152.  
  153. return imaginary; 
  154.  
  155.  
  156. -(void) print { 
  157.  
  158. printf( "%_f + %_fi", real, imaginary ); 
  159.  
  160.  
  161. @end 
  162.  
  163. main.m 
  164.  
  165. #import 
  166.  
  167. #import "Fraction.h" 
  168.  
  169. #import "Complex.h" 
  170.  
  171. int main( int argc, const char *argv[] ) { 
  172.  
  173. // create a new instance 
  174.  
  175. Fraction *frac = [[Fraction alloc] initWithNumerator: 1 denominator: 10]; 
  176.  
  177. Complex *comp = [[Complex alloc] initWithReal: 10 andImaginary: 15]; 
  178.  
  179. id number; 
  180.  
  181. // print fraction 
  182.  
  183. number = frac
  184.  
  185. printf( "The fraction is: " ); 
  186.  
  187. [number print]; 
  188.  
  189. printf( "\n" ); 
  190.  
  191. // print complex 
  192.  
  193. number = comp
  194.  
  195. printf( "The complex number is: " ); 
  196.  
  197. [number print]; 
  198.  
  199. printf( "\n" ); 
  200.  
  201. // free memory 
  202.  
  203. [frac release]; 
  204.  
  205. [comp release]; 
  206.  
  207. return 0; 
  208.  

output

  1. The fraction is: 1 / 10 
  2.  
  3. The complex number is: 10.000000 + 15.000000i 

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

继承(Inheritance)

  1. Rectangle.h 
  2.  
  3. #import 
  4.  
  5. @interface Rectangle: NSObject { 
  6.  
  7. int width; 
  8.  
  9. int height; 
  10.  
  11.  
  12. -(Rectangle*) initWithWidth: (int) w height: (int) h; 
  13.  
  14. -(void) setWidth: (int) w; 
  15.  
  16. -(void) setHeight: (int) h; 
  17.  
  18. -(void) setWidth: (int) w height: (int) h; 
  19.  
  20. -(int) width; 
  21.  
  22. -(int) height; 
  23.  
  24. -(void) print; 
  25.  
  26. @end 
  27.  
  28. Rectangle.m 
  29.  
  30. #import "Rectangle.h" 
  31.  
  32. #import 
  33.  
  34. @implementation Rectangle 
  35.  
  36. -(Rectangle*) initWithWidth: (int) w height: (int) h { 
  37.  
  38. self = [super init]; 
  39.  
  40. if ( self ) { 
  41.  
  42. [self setWidth: w height: h]; 
  43.  
  44.  
  45. return self; 
  46.  
  47.  
  48. -(void) setWidth: (int) w { 
  49.  
  50. wwidth = w; 
  51.  
  52.  
  53. -(void) setHeight: (int) h { 
  54.  
  55. hheight = h; 
  56.  
  57.  
  58. -(void) setWidth: (int) w height: (int) h { 
  59.  
  60. wwidth = w; 
  61.  
  62. hheight = h; 
  63.  
  64.  
  65. -(int) width { 
  66.  
  67. return width; 
  68.  
  69.  
  70. -(int) height { 
  71.  
  72. return height; 
  73.  
  74.  
  75. -(void) print { 
  76.  
  77. printf( "width = %i, height = %i", width, height ); 
  78.  
  79.  
  80. @end 
  81.  
  82. Square.h 
  83.  
  84. #import "Rectangle.h" 
  85.  
  86. @interface Square: Rectangle 
  87.  
  88. -(Square*) initWithSize: (int) s; 
  89.  
  90. -(void) setSize: (int) s; 
  91.  
  92. -(int) size; 
  93.  
  94. @end 
  95.  
  96. Square.m 
  97.  
  98. #import "Square.h" 
  99.  
  100. @implementation Square 
  101.  
  102. -(Square*) initWithSize: (int) s { 
  103.  
  104. self = [super init]; 
  105.  
  106. if ( self ) { 
  107.  
  108. [self setSize: s]; 
  109.  
  110.  
  111. return self; 
  112.  
  113.  
  114. -(void) setSize: (int) s { 
  115.  
  116. width = s
  117.  
  118. height = s
  119.  
  120.  
  121. -(int) size { 
  122.  
  123. return width; 
  124.  
  125.  
  126. -(void) setWidth: (int) w { 
  127.  
  128. [self setSize: w]; 
  129.  
  130.  
  131. -(void) setHeight: (int) h { 
  132.  
  133. [self setSize: h]; 
  134.  
  135.  
  136. @end 
  137.  
  138. main.m 
  139.  
  140. #import "Square.h" 
  141.  
  142. #import "Rectangle.h" 
  143.  
  144. #import 
  145.  
  146. int main( int argc, const char *argv[] ) { 
  147.  
  148. Rectangle *rec = [[Rectangle alloc] initWithWidth: 10 height: 20]; 
  149.  
  150. Square *sq = [[Square alloc] initWithSize: 15]; 
  151.  
  152. // print em 
  153.  
  154. printf( "Rectangle: " ); 
  155.  
  156. [rec print]; 
  157.  
  158. printf( "\n" ); 
  159.  
  160. printf( "Square: " ); 
  161.  
  162. [sq print]; 
  163.  
  164. printf( "\n" ); 
  165.  
  166. // update square 
  167.  
  168. [sq setWidth: 20]; 
  169.  
  170. printf( "Square after change: " ); 
  171.  
  172. [sq print]; 
  173.  
  174. printf( "\n" ); 
  175.  
  176. // free memory 
  177.  
  178. [rec release]; 
  179.  
  180. [sq release]; 
  181.  
  182. return 0; 
  183.  

output

  1. Rectangle: width = 10height = 20 
  2.  
  3. Square: width = 15height = 15 
  4.  
  5. Square after change: width = 20height = 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(说明部分採中英并列,因为我觉得英文比较传神,中文怎么译都怪):

  1. -(BOOL) isKindOfClass: classObjis object a descendent or member of classObj 

此物件是否是 classObj 的子孙或一员

  1. -(BOOL) isMemberOfClass: classObjis object a member of classObj 

此物件是否是 classObj 的一员

  1. -(BOOL) respondsToSelector: selectordoes the object have a method named specifiec by the selector 

此物件是否有叫做 selector 的 method

  1. +(BOOL) instancesRespondToSelector: selectordoes an object created by this class have the ability to respond to the specified selector 

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

  1. -(id) performSelector: selectorinvoke the specified selector on the object 

唤起此物件的指定 selector

所有继承自 NSObject 都有一个可回传一个 class 物件的 class method。这非常近似于 Java 的 getClass() method。这个 class 物件被使用于前述的 methods 中。

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

  1. main.m 
  2.  
  3. #import "Square.h" 
  4.  
  5. #import "Rectangle.h" 
  6.  
  7. #import 
  8.  
  9. int main( int argc, const char *argv[] ) { 
  10.  
  11. Rectangle *rec = [[Rectangle alloc] initWithWidth: 10 height: 20]; 
  12.  
  13. Square *sq = [[Square alloc] initWithSize: 15]; 
  14.  
  15. // isMemberOfClass 
  16.  
  17. // true 
  18.  
  19. if ( [sq isMemberOfClass: [Square class]] == YES ) { 
  20.  
  21. printf( "square is a member of square class\n" ); 
  22.  
  23.  
  24. // false 
  25.  
  26. if ( [sq isMemberOfClass: [Rectangle class]] == YES ) { 
  27.  
  28. printf( "square is a member of rectangle class\n" ); 
  29.  
  30.  
  31. // false 
  32.  
  33. if ( [sq isMemberOfClass: [NSObject class]] == YES ) { 
  34.  
  35. printf( "square is a member of object class\n" ); 
  36.  
  37.  
  38. // isKindOfClass 
  39.  
  40. // true 
  41.  
  42. if ( [sq isKindOfClass: [Square class]] == YES ) { 
  43.  
  44. printf( "square is a kind of square class\n" ); 
  45.  
  46.  
  47. // true 
  48.  
  49. if ( [sq isKindOfClass: [Rectangle class]] == YES ) { 
  50.  
  51. printf( "square is a kind of rectangle class\n" ); 
  52.  
  53.  
  54. // true 
  55.  
  56. if ( [sq isKindOfClass: [NSObject class]] == YES ) { 
  57.  
  58. printf( "square is a kind of object class\n" ); 
  59.  
  60.  
  61. // respondsToSelector 
  62.  
  63. // true 
  64.  
  65. if ( [sq respondsToSelector: @selector( setSize: )] == YES ) { 
  66.  
  67. printf( "square responds to setSize: method\n" ); 
  68.  
  69.  
  70. // false 
  71.  
  72. if ( [sq respondsToSelector: @selector( nonExistant )] == YES ) { 
  73.  
  74. printf( "square responds to nonExistant method\n" ); 
  75.  
  76.  
  77. // true 
  78.  
  79. if ( [Square respondsToSelector: @selector( alloc )] == YES ) { 
  80.  
  81. printf( "square class responds to alloc method\n" ); 
  82.  
  83.  
  84. // instancesRespondToSelector 
  85.  
  86. // false 
  87.  
  88. if ( [Rectangle instancesRespondToSelector: @selector( setSize: )] == YES ) { 
  89.  
  90. printf( "rectangle instance responds to setSize: method\n" ); 
  91.  
  92.  
  93. // true 
  94.  
  95. if ( [Square instancesRespondToSelector: @selector( setSize: )] == YES ) { 
  96.  
  97. printf( "square instance responds to setSize: method\n" ); 
  98.  
  99.  
  100. // free memory 
  101.  
  102. [rec release]; 
  103.  
  104. [sq release]; 
  105.  
  106. return 0; 
  107.  

output

  1. square is a member of square class 
  2.  
  3. square is a kind of square class 
  4.  
  5. square is a kind of rectangle class 
  6.  
  7. square is a kind of object class 
  8.  
  9. square responds to setSize: method 
  10.  
  11. square class responds to alloc method 
  12.  
  13. square instance responds to setSize: method 
  14.  
  15. Categories 

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

  1. FractionMath.h 
  2.  
  3. #import "Fraction.h" 
  4.  
  5. @interface Fraction (Math) 
  6.  
  7. -(Fraction*) add: (Fraction*) f; 
  8.  
  9. -(Fraction*) mul: (Fraction*) f; 
  10.  
  11. -(Fraction*) div: (Fraction*) f; 
  12.  
  13. -(Fraction*) sub: (Fraction*) f; 
  14.  
  15. @end 
  16.  
  17. FractionMath.m 
  18.  
  19. #import "FractionMath.h" 
  20.  
  21. @implementation Fraction (Math) 
  22.  
  23. -(Fraction*) add: (Fraction*) f { 
  24.  
  25. return [[Fraction alloc] initWithNumerator: numerator * [f denominator] + 
  26.  
  27. denominator * [f numerator] 
  28.  
  29. denominator: denominator * [f denominator]]; 
  30.  
  31.  
  32. -(Fraction*) mul: (Fraction*) f { 
  33.  
  34. return [[Fraction alloc] initWithNumerator: numerator * [f numerator] 
  35.  
  36. denominator: denominator * [f denominator]]; 
  37.  
  38.  
  39. -(Fraction*) div: (Fraction*) f { 
  40.  
  41. return [[Fraction alloc] initWithNumerator: numerator * [f denominator] 
  42.  
  43. denominator: denominator * [f numerator]]; 
  44.  
  45.  
  46. -(Fraction*) sub: (Fraction*) f { 
  47.  
  48. return [[Fraction alloc] initWithNumerator: numerator * [f denominator] - 
  49.  
  50. denominator * [f numerator] 
  51.  
  52. denominator: denominator * [f denominator]]; 
  53.  
  54.  
  55. @end 
  56.  
  57. main.m 
  58.  
  59. #import 
  60.  
  61. #import "Fraction.h" 
  62.  
  63. #import "FractionMath.h" 
  64.  
  65. int main( int argc, const char *argv[] ) { 
  66.  
  67. // create a new instance 
  68.  
  69. Fraction *frac1 = [[Fraction alloc] initWithNumerator: 1 denominator: 3]; 
  70.  
  71. Fraction *frac2 = [[Fraction alloc] initWithNumerator: 2 denominator: 5]; 
  72.  
  73. Fraction *frac3 = [frac1 mul: frac2]; 
  74.  
  75. // print it 
  76.  
  77. [frac1 print]; 
  78.  
  79. printf( " * " ); 
  80.  
  81. [frac2 print]; 
  82.  
  83. printf( " = " ); 
  84.  
  85. [frac3 print]; 
  86.  
  87. printf( "\n" ); 
  88.  
  89. // free memory 
  90.  
  91. [frac1 release]; 
  92.  
  93. [frac2 release]; 
  94.  
  95. [frac3 release]; 
  96.  
  97. return 0; 
  98.  

output

  1. 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) 档案。以下是此种作法一个简短的範例。

  1. MyClass.h 
  2.  
  3. #import 
  4.  
  5. @interface MyClass: NSObject 
  6.  
  7. -(void) publicMethod; 
  8.  
  9. @end 
  10.  
  11. MyClass.m 
  12.  
  13. #import "MyClass.h" 
  14.  
  15. #import 
  16.  
  17. @implementation MyClass 
  18.  
  19. -(void) publicMethod { 
  20.  
  21. printf( "public method\n" ); 
  22.  
  23.  
  24. @end 
  25.  
  26. // private methods 
  27.  
  28. @interface MyClass (Private) 
  29.  
  30. -(void) privateMethod; 
  31.  
  32. @end 
  33.  
  34. @implementation MyClass (Private) 
  35.  
  36. -(void) privateMethod { 
  37.  
  38. printf( "private method\n" ); 
  39.  
  40.  
  41. @end 
  42.  
  43. main.m 
  44.  
  45. #import "MyClass.h" 
  46.  
  47. int main( int argc, const char *argv[] ) { 
  48.  
  49. MyClass *obj = [[MyClass alloc] init]; 
  50.  
  51. // this compiles 
  52.  
  53. [obj publicMethod]; 
  54.  
  55. // this throws errors when compiling 
  56.  
  57. //[obj privateMethod]; 
  58.  
  59. // free memory 
  60.  
  61. [obj release]; 
  62.  
  63. return 0; 
  64.  

output

  1. public method 
  2.  
  3. Posing 

Posing 有点像 categories,但是不太一样。它允许你扩充一个 class,并且全面性地的扮演(pose)这个 super class。例如:你有一个扩充 NSArray 的 NSArrayChild 物件。如果你让 NSArrayChild 扮演 NSArray,则在你的程式码中所有的 NSArray 都会自动被替代为 NSArrayChild。

  1. FractionB.h 
  2.  
  3. #import "Fraction.h" 
  4.  
  5. @interface FractionB: Fraction 
  6.  
  7. -(void) print; 
  8.  
  9. @end 
  10.  
  11. FractionB.m 
  12.  
  13. #import "FractionB.h" 
  14.  
  15. #import 
  16.  
  17. @implementation FractionB 
  18.  
  19. -(void) print { 
  20.  
  21. printf( "(%i/%i)", numerator, denominator ); 
  22.  
  23.  
  24. @end 
  25.  
  26. main.m 
  27.  
  28. #import 
  29.  
  30. #import "Fraction.h" 
  31.  
  32. #import "FractionB.h" 
  33.  
  34. int main( int argc, const char *argv[] ) { 
  35.  
  36. Fraction *frac = [[Fraction alloc] initWithNumerator: 3 denominator: 10]; 
  37.  
  38. // print it 
  39.  
  40. printf( "The fraction is: " ); 
  41.  
  42. [frac print]; 
  43.  
  44. printf( "\n" ); 
  45.  
  46. // make FractionB pose as Fraction 
  47.  
  48. [FractionB poseAsClass: [Fraction class]]; 
  49.  
  50. Fraction *frac2 = [[Fraction alloc] initWithNumerator: 3 denominator: 10]; 
  51.  
  52. // print it 
  53.  
  54. printf( "The fraction is: " ); 
  55.  
  56. [frac2 print]; 
  57.  
  58. printf( "\n" ); 
  59.  
  60. // free memory 
  61.  
  62. [frac release]; 
  63.  
  64. [frac2 release]; 
  65.  
  66. return 0; 
  67.  

output

  1. The fraction is: 3/10 
  2.  
  3. 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 相同。

  1. Printing.h 
  2.  
  3. @protocol Printing 
  4.  
  5. -(void) print; 
  6.  
  7. @end 
  8.  
  9. Fraction.h 
  10.  
  11. #import 
  12.  
  13. #import "Printing.h" 
  14.  
  15. @interface Fraction: NSObject { 
  16.  
  17. int numerator; 
  18.  
  19. int denominator; 
  20.  
  21.  
  22. -(Fraction*) initWithNumerator: (int) n denominator: (int) d; 
  23.  
  24. -(void) setNumerator: (int) d; 
  25.  
  26. -(void) setDenominator: (int) d; 
  27.  
  28. -(void) setNumerator: (int) n andDenominator: (int) d; 
  29.  
  30. -(int) numerator; 
  31.  
  32. -(int) denominator; 
  33.  
  34. @end 
  35.  
  36. Fraction.m 
  37.  
  38. #import "Fraction.h" 
  39.  
  40. #import 
  41.  
  42. @implementation Fraction 
  43.  
  44. -(Fraction*) initWithNumerator: (int) n denominator: (int) d { 
  45.  
  46. self = [super init]; 
  47.  
  48. if ( self ) { 
  49.  
  50. [self setNumerator: n andDenominator: d]; 
  51.  
  52.  
  53. return self; 
  54.  
  55.  
  56. -(void) print { 
  57.  
  58. printf( "%i/%i", numerator, denominator ); 
  59.  
  60.  
  61. -(void) setNumerator: (int) n { 
  62.  
  63. nnumerator = n; 
  64.  
  65.  
  66. -(void) setDenominator: (int) d { 
  67.  
  68. ddenominator = d; 
  69.  
  70.  
  71. -(void) setNumerator: (int) n andDenominator: (int) d { 
  72.  
  73. nnumerator = n; 
  74.  
  75. ddenominator = d; 
  76.  
  77.  
  78. -(int) denominator { 
  79.  
  80. return denominator; 
  81.  
  82.  
  83. -(int) numerator { 
  84.  
  85. return numerator; 
  86.  
  87.  
  88. -(Fraction*) copyWithZone: (NSZone*) zone { 
  89.  
  90. return [[Fraction allocWithZone: zone] initWithNumerator: numerator 
  91.  
  92. denominator: denominator]; 
  93.  
  94.  
  95. @end 
  96.  
  97. Complex.h 
  98.  
  99. #import 
  100.  
  101. #import "Printing.h" 
  102.  
  103. @interface Complex: NSObject { 
  104.  
  105. double real; 
  106.  
  107. double imaginary; 
  108.  
  109.  
  110. -(Complex*) initWithReal: (double) r andImaginary: (double) i; 
  111.  
  112. -(void) setReal: (double) r; 
  113.  
  114. -(void) setImaginary: (double) i; 
  115.  
  116. -(void) setReal: (double) r andImaginary: (double) i; 
  117.  
  118. -(double) real; 
  119.  
  120. -(double) imaginary; 
  121.  
  122. @end 
  123.  
  124. Complex.m 
  125.  
  126. #import "Complex.h" 
  127.  
  128. #import 
  129.  
  130. @implementation Complex 
  131.  
  132. -(Complex*) initWithReal: (double) r andImaginary: (double) i { 
  133.  
  134. self = [super init]; 
  135.  
  136. if ( self ) { 
  137.  
  138. [self setReal: r andImaginary: i]; 
  139.  
  140.  
  141. return self; 
  142.  
  143.  
  144. -(void) setReal: (double) r { 
  145.  
  146. rreal = r; 
  147.  
  148.  
  149. -(void) setImaginary: (double) i { 
  150.  
  151. iimaginary = i; 
  152.  
  153.  
  154. -(void) setReal: (double) r andImaginary: (double) i { 
  155.  
  156. rreal = r; 
  157.  
  158. iimaginary = i; 
  159.  
  160.  
  161. -(double) real { 
  162.  
  163. return real; 
  164.  
  165.  
  166. -(double) imaginary { 
  167.  
  168. return imaginary; 
  169.  
  170.  
  171. -(void) print { 
  172.  
  173. printf( "%_f + %_fi", real, imaginary ); 
  174.  
  175.  
  176. @end 
  177.  
  178. main.m 
  179.  
  180. #import 
  181.  
  182. #import "Fraction.h" 
  183.  
  184. #import "Complex.h" 
  185.  
  186. int main( int argc, const char *argv[] ) { 
  187.  
  188. // create a new instance 
  189.  
  190. Fraction *frac = [[Fraction alloc] initWithNumerator: 3 denominator: 10]; 
  191.  
  192. Complex *comp = [[Complex alloc] initWithReal: 5 andImaginary: 15]; 
  193.  
  194. id printable; 
  195.  
  196. id copyPrintable; 
  197.  
  198. // print it 
  199.  
  200. printable = frac
  201.  
  202. printf( "The fraction is: " ); 
  203.  
  204. [printable print]; 
  205.  
  206. printf( "\n" ); 
  207.  
  208. // print complex 
  209.  
  210. printable = comp
  211.  
  212. printf( "The complex number is: " ); 
  213.  
  214. [printable print]; 
  215.  
  216. printf( "\n" ); 
  217.  
  218. // this compiles because Fraction comforms to both Printing and NSCopyable 
  219.  
  220. copyPrintable = frac
  221.  
  222. // this doesn't compile because Complex only conforms to Printing 
  223.  
  224. //copyPrintable = comp
  225.  
  226. // test conformance 
  227.  
  228. // true 
  229.  
  230. if ( [frac conformsToProtocol: @protocol( NSCopying )] == YES ) { 
  231.  
  232. printf( "Fraction conforms to NSCopying\n" ); 
  233.  
  234.  
  235. // false 
  236.  
  237. if ( [comp conformsToProtocol: @protocol( NSCopying )] == YES ) { 
  238.  
  239. printf( "Complex conforms to NSCopying\n" ); 
  240.  
  241.  
  242. // free memory 
  243.  
  244. [frac release]; 
  245.  
  246. [comp release]; 
  247.  
  248. return 0; 
  249.  

output

  1. The fraction is: 3/10 
  2.  
  3. The complex number is: 5.000000 + 15.000000i 
  4.  
  5. Fraction conforms to NSCopying 

protocol 的宣告十分简单,基本上就是 @protocol ProtocolName (methods you must implement) @end。

要遵从(conform)某个 protocol,将要遵从的 protocols 放在 <> 裡面,并以逗点分隔。如:@interface SomeClass

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

Objective-C 的介面系统有一个独一无二的观念是如何指定一个型别。比起 C++ 或 Java 的指定方式,如:Printing *someVar = ( Printing * ) frac; 你可以使用 id 型别加上 protocol:id var = frac;。这让你可以动态地指定一个要求多个 protocol 的型别,却从头到尾只用了一个变数。如: 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。

  1. Fraction.m 
  2.  
  3. ... 
  4.  
  5. -(void) dealloc { 
  6.  
  7. printf( "Deallocing fraction\n" ); 
  8.  
  9. [super dealloc]; 
  10.  
  11.  
  12. ... 
  1. main.m 
  2.  
  3. #import "Fraction.h" 
  4.  
  5. #import 
  6.  
  7. int main( int argc, const char *argv[] ) { 
  8.  
  9. Fraction *frac1 = [[Fraction alloc] init]; 
  10.  
  11. Fraction *frac2 = [[Fraction alloc] init]; 
  12.  
  13. // print current counts 
  14.  
  15. printf( "Fraction 1 retain count: %i\n", [frac1 retainCount] ); 
  16.  
  17. printf( "Fraction 2 retain count: %i\n", [frac2 retainCount] ); 
  18.  
  19. // increment them 
  20.  
  21. [frac1 retain]; // 2 
  22.  
  23. [frac1 retain]; // 3 
  24.  
  25. [frac2 retain]; // 2 
  26.  
  27. // print current counts 
  28.  
  29. printf( "Fraction 1 retain count: %i\n", [frac1 retainCount] ); 
  30.  
  31. printf( "Fraction 2 retain count: %i\n", [frac2 retainCount] ); 
  32.  
  33. // decrement 
  34.  
  35. [frac1 release]; // 2 
  36.  
  37. [frac2 release]; // 1 
  38.  
  39. // print current counts 
  40.  
  41. printf( "Fraction 1 retain count: %i\n", [frac1 retainCount] ); 
  42.  
  43. printf( "Fraction 2 retain count: %i\n", [frac2 retainCount] ); 
  44.  
  45. // release them until they dealloc themselves 
  46.  
  47. [frac1 release]; // 1 
  48.  
  49. [frac1 release]; // 0 
  50.  
  51. [frac2 release]; // 0 
  52.  

output

  1. Fraction 1 retain count: 1 
  2.  
  3. Fraction 2 retain count: 1 
  4.  
  5. Fraction 1 retain count: 3 
  6.  
  7. Fraction 2 retain count: 2 
  8.  
  9. Fraction 1 retain count: 2 
  10.  
  11. Fraction 2 retain count: 1 
  12.  
  13. Deallocing fraction 
  14.  
  15. Deallocing fraction 

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

Dealloc

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

AddressCard.h

  1. #import 
  2.  
  3. #import 
  4.  
  5. @interface AddressCard: NSObject { 
  6.  
  7. NSString *first; 
  8.  
  9. NSString *last; 
  10.  
  11. NSString *email; 
  12.  
  13.  
  14. -(AddressCard*) initWithFirst: (NSString*) f 
  15.  
  16. last: (NSString*) l 
  17.  
  18. email: (NSString*) e; 
  19.  
  20. -(NSString*) first; 
  21.  
  22. -(NSString*) last; 
  23.  
  24. -(NSString*) email; 
  25.  
  26. -(void) setFirst: (NSString*) f; 
  27.  
  28. -(void) setLast: (NSString*) l; 
  29.  
  30. -(void) setEmail: (NSString*) e; 
  31.  
  32. -(void) setFirst: (NSString*) f 
  33.  
  34. last: (NSString*) l 
  35.  
  36. email: (NSString*) e; 
  37.  
  38. -(void) setFirst: (NSString*) f last: (NSString*) l; 
  39.  
  40. -(void) print; 
  41.  
  42. @end 
  43.  
  44. AddressCard.m 
  45.  
  46. #import "AddressCard.h" 
  47.  
  48. #import 
  49.  
  50. @implementation AddressCard 
  51.  
  52. -(AddressCard*) initWithFirst: (NSString*) f 
  53.  
  54. last: (NSString*) l 
  55.  
  56. email: (NSString*) e { 
  57.  
  58. self = [super init]; 
  59.  
  60. if ( self ) { 
  61.  
  62. [self setFirst: f last: l email: e]; 
  63.  
  64.  
  65. return self; 
  66.  
  67.  
  68. -(NSString*) first { 
  69.  
  70. return first; 
  71.  
  72.  
  73. -(NSString*) last { 
  74.  
  75. return last; 
  76.  
  77.  
  78. -(NSString*) email { 
  79.  
  80. return email; 
  81.  
  82.  
  83. -(void) setFirst: (NSString*) f { 
  84.  
  85. [f retain]; 
  86.  
  87. [first release]; 
  88.  
  89. ffirst = f; 
  90.  
  91.  
  92. -(void) setLast: (NSString*) l { 
  93.  
  94. [l retain]; 
  95.  
  96. [last release]; 
  97.  
  98. llast = l; 
  99.  
  100.  
  101. -(void) setEmail: (NSString*) e { 
  102.  
  103. [e retain]; 
  104.  
  105. [email release]; 
  106.  
  107. eemail = e; 
  108.  
  109.  
  110. -(void) setFirst: (NSString*) f 
  111.  
  112. last: (NSString*) l 
  113.  
  114. email: (NSString*) e { 
  115.  
  116. [self setFirst: f]; 
  117.  
  118. [self setLast: l]; 
  119.  
  120. [self setEmail: e]; 
  121.  
  122.  
  123. -(void) setFirst: (NSString*) f last: (NSString*) l { 
  124.  
  125. [self setFirst: f]; 
  126.  
  127. [self setLast: l]; 
  128.  
  129.  
  130. -(void) print { 
  131.  
  132. printf( "%s %s <%S> 
  133.  
  134. ", [first cString], 
  135.  
  136. [last cString], 
  137.  
  138. [email cString] ); 
  139.  
  140.  
  141. -(void) dealloc { 
  142.  
  143. [first release]; 
  144.  
  145. [last release]; 
  146.  
  147. [email release]; 
  148.  
  149. [super dealloc]; 
  150.  
  151.  
  152. @end 
  153.  
  154. main.m 
  155.  
  156. #import "AddressCard.h" 
  157.  
  158. #import 
  159.  
  160. #import 
  161.  
  162. int main( int argc, const char *argv[] ) { 
  163.  
  164. NSString *first =[[NSString alloc] initWithCString: "Tom"]; 
  165.  
  166. NSString *last = [[NSString alloc] initWithCString: "Jones"]; 
  167.  
  168. NSString *email = [[NSString alloc] initWithCString: "tom@jones.com"]; 
  169.  
  170. AddressCard *tom = [[AddressCard alloc] initWithFirst: first 
  171.  
  172. last: last 
  173.  
  174. email: email]; 
  175.  
  176. // we're done with the strings, so we must dealloc them 
  177.  
  178. [first release]; 
  179.  
  180. [last release]; 
  181.  
  182. [email release]; 
  183.  
  184. // print to show the retain count 
  185.  
  186. printf( "Retain count: %i\n", [[tom first] retainCount] ); 
  187.  
  188. [tom print]; 
  189.  
  190. printf( "\n" ); 
  191.  
  192. // free memory 
  193.  
  194. [tom release]; 
  195.  
  196. return 0; 
  197.  

output

  1. Retain count: 1 
  2.  
  3. Tom Jones  

如 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 会自动地帮你设定好。

  1. main.m 
  2.  
  3. #import 
  4.  
  5. #import 
  6.  
  7. #import 
  8.  
  9. int main( int argc, const char *argv[] ) { 
  10.  
  11. NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init]; 
  12.  
  13. NSString *str1 = @"constant string"; 
  14.  
  15. NSString *str2 = [NSString stringWithString: @"string managed by the pool"]; 
  16.  
  17. NSString *str3 = [[NSString alloc] initWithString: @"self managed string"]; 
  18.  
  19. // print the strings 
  20.  
  21. printf( "%s retain count: %x\n", [str1 cString], [str1 retainCount] ); 
  22.  
  23. printf( "%s retain count: %x\n", [str2 cString], [str2 retainCount] ); 
  24.  
  25. printf( "%s retain count: %x\n", [str3 cString], [str3 retainCount] ); 
  26.  
  27. // free memory 
  28.  
  29. [str3 release]; 
  30.  
  31. // free pool 
  32.  
  33. [pool release]; 
  34.  
  35. return 0; 
  36.  

output

  1. constant string retain count: ffffffff 
  2.  
  3. string managed by the pool retain count: 1 
  4.  
  5. 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。

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

  1. Fraction.h 
  2.  
  3. ... 
  4.  
  5. +(Fraction*) fractionWithNumerator: (int) n denominator: (int) d; 
  6.  
  7. ... 
  8.  
  9. Fraction.m 
  10.  
  11. ... 
  12.  
  13. +(Fraction*) fractionWithNumerator: (int) n denominator: (int) d { 
  14.  
  15. Fraction *ret = [[Fraction alloc] initWithNumerator: n denominator: d]; 
  16.  
  17. [ret autorelease]; 
  18.  
  19. return ret; 
  20.  
  21.  
  22. ... 
  23.  
  24. main.m 
  25.  
  26. #import 
  27.  
  28. #import "Fraction.h" 
  29.  
  30. #import 
  31.  
  32. int main( int argc, const char *argv[] ) { 
  33.  
  34. NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init]; 
  35.  
  36. Fraction *frac1 = [Fraction fractionWithNumerator: 2 denominator: 5]; 
  37.  
  38. Fraction *frac2 = [Fraction fractionWithNumerator: 1 denominator: 3]; 
  39.  
  40. // print frac 1 
  41.  
  42. printf( "Fraction 1: " ); 
  43.  
  44. [frac1 print]; 
  45.  
  46. printf( "\n" ); 
  47.  
  48. // print frac 2 
  49.  
  50. printf( "Fraction 2: " ); 
  51.  
  52. [frac2 print]; 
  53.  
  54. printf( "\n" ); 
  55.  
  56. // this causes a segmentation fault 
  57.  
  58. //[frac1 release]; 
  59.  
  60. // release the pool and all objects in it 
  61.  
  62. [pool release]; 
  63.  
  64. return 0; 
  65.  

output

  1. Fraction 1: 2/5 
  2.  
  3. 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

  1. main.m 
  2.  
  3. #import 
  4.  
  5. #import 
  6.  
  7. #import 
  8.  
  9. #import 
  10.  
  11. #import 
  12.  
  13. void print( NSArray *array ) { 
  14.  
  15. NSEnumerator *enumerator = [array objectEnumerator]; 
  16.  
  17. id obj; 
  18.  
  19. while ( obj = [enumerator nextObject] ) { 
  20.  
  21. printf( "%s\n", [[obj description] cString] ); 
  22.  
  23.  
  24.  
  25. int main( int argc, const char *argv[] ) { 
  26.  
  27. NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init]; 
  28.  
  29. NSArray *arr = [[NSArray alloc] initWithObjects: 
  30.  
  31. @"Me", @"Myself", @"I", nil]; 
  32.  
  33. NSMutableArray *mutable = [[NSMutableArray alloc] init]; 
  34.  
  35. // enumerate over items 
  36.  
  37. printf( "----static array\n" ); 
  38.  
  39. print( arr ); 
  40.  
  41. // add stuff 
  42.  
  43. [mutable addObject: @"One"]; 
  44.  
  45. [mutable addObject: @"Two"]; 
  46.  
  47. [mutable addObjectsFromArray: arr]; 
  48.  
  49. [mutable addObject: @"Three"]; 
  50.  
  51. // print em 
  52.  
  53. printf( "----mutable array\n" ); 
  54.  
  55. print( mutable ); 
  56.  
  57. // sort then print 
  58.  
  59. printf( "----sorted mutable array\n" ); 
  60.  
  61. [mutable sortUsingSelector: @selector( caseInsensitiveCompare: )]; 
  62.  
  63. print( mutable ); 
  64.  
  65. // free memory 
  66.  
  67. [arr release]; 
  68.  
  69. [mutable release]; 
  70.  
  71. [pool release]; 
  72.  
  73. return 0; 
  74.  

output

  1. ----static array 
  2.  
  3. Me 
  4.  
  5. Myself 
  6.  
  7.  
  8. ----mutable array 
  9.  
  10. One 
  11.  
  12. Two 
  13.  
  14. Me 
  15.  
  16. Myself 
  17.  
  18.  
  19. Three 
  20.  
  21. ----sorted mutable array 
  22.  
  23.  
  24. Me 
  25.  
  26. Myself 
  27.  
  28. One 
  29.  
  30. Three 
  31.  
  32. 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

  1. main.m 
  2.  
  3. #import 
  4.  
  5. #import 
  6.  
  7. #import 
  8.  
  9. #import 
  10.  
  11. #import <<> 
  12.  
  13. #import 
  14.  
  15. void print( NSDictionary *map ) { 
  16.  
  17. NSEnumerator *enumerator = [map keyEnumerator]; 
  18.  
  19. id key; 
  20.  
  21. while ( key = [enumerator nextObject] ) { 
  22.  
  23. printf( "%s => %s\n", 
  24.  
  25. [[key description] cString], 
  26.  
  27. [[[map objectForKey: key] description] cString] ); 
  28.  
  29.  
  30.  
  31. int main( int argc, const char *argv[] ) { 
  32.  
  33. NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init]; 
  34.  
  35. NSDictionary *dictionary = [[NSDictionary alloc] initWithObjectsAndKeys: 
  36.  
  37. @"one", [NSNumber numberWithInt: 1], 
  38.  
  39. @"two", [NSNumber numberWithInt: 2], 
  40.  
  41. @"three", [NSNumber numberWithInt: 3], 
  42.  
  43. nil]; 
  44.  
  45. NSMutableDictionary *mutable = [[NSMutableDictionary alloc] init]; 
  46.  
  47. // print dictionary 
  48.  
  49. printf( "----static dictionary\n" ); 
  50.  
  51. print( dictionary ); 
  52.  
  53. // add objects 
  54.  
  55. [mutable setObject: @"Tom" forKey: @"tom@jones.com"]; 
  56.  
  57. [mutable setObject: @"Bob" forKey: @"bob@dole.com" ]; 
  58.  
  59. // print mutable dictionary 
  60.  
  61. printf( "----mutable dictionary\n" ); 
  62.  
  63. print( mutable ); 
  64.  
  65. // free memory 
  66.  
  67. [dictionary release]; 
  68.  
  69. [mutable release]; 
  70.  
  71. [pool release]; 
  72.  
  73. return 0; 
  74.  
  75.  

output

  1. ----static dictionary  
  2.   
  3. 1 => one  
  4.   
  5. 2 => two  
  6.   
  7. 3 => three  
  8.   
  9. ----mutable dictionary  
  10.   
  11. bob@dole.com => Bob  
  12.   
  13. tom@jones.com => Tom  

优点与缺点

优点

Cateogies

Posing

动态识别

指标计算

弹性讯息传递

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

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

缺点

不支援命名空间

不支援运算子多载(虽然这常常被视为一个优点,不过正确地使用运算子多载可以降低程式码复杂度)

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

【责任编辑:立方 TEL:(010)68476606】

点赞 0
分享:
大家都在看
猜你喜欢

订阅专栏+更多

Redis运维秘籍

Redis运维秘籍

运维标配技术
共15章 | one叶孤舟

39人订阅学习

活学活用 Ubuntu Server

活学活用 Ubuntu Server

实战直通车
共35章 | UbuntuServer

233人订阅学习

Java EE速成指南

Java EE速成指南

掌握Java核心
共30章 | 51CTO王波

89人订阅学习

读 书 +更多

Oracle 10g应用指导与案例精讲

本书作者结合自己多年实践经验,从Oracle开发应用中遇到的问题着手,全面系统地介绍Oracle的安装与卸载、数据字典、安全管理以及用PL/SQL开...

订阅51CTO邮刊

点击这里查看样刊

订阅51CTO邮刊

51CTO服务号

51CTO播客