Object-C 新手教程

大纲

• 開始吧
  • 下载这篇教学
  • 设定环境
  • 前言
  • 编译 hello world
• 创建 Classes
  • @interface
  • @implementation
  • 把它们凑在一起
• 具体说明...
  • 多重參数
  • 建构子（Constructors）
  • 訪问权限
  • Class level access
  • 异常情况（Exceptions）处理
• 继承、多型（Inheritance, Polymorphism）以及其它面向对象功能
  • id 型别
  • 继承（Inheritance）
  • 动态识别（Dynamic types）
  • Categories
  • Posing
  • Protocols
• 内存管理
  • Retain and Release（保留与释放）
  • Dealloc
  • Autorelease Pool
• Foundation Framework Classes
  • NSArray
  • NSDictionary
• 长处与缺点
• 很多其它信息

• 開始吧
  • 下载这篇教学
    • 全部这篇刚開始学习的人指南的原始码都能够由 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（说明部分採中英并列，由于我认为英文比較传神，中文怎么译都怪）：

•  
  •  
    • 全部继承自 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];

§  }

...

•  
  •  
    • 基于 "Programming in Objective-C," Copyright © 2004 by Sams Publishing一书中的范例，并经过同意而刊载。
    • main.m

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