objecttive_c 介绍

Objective-C 
编程范型 面向对象 
发行时间 1986 
设计者 Tom Love和Brad Cox 
实作者 Apple Inc. 
型态系统 弱类型，动态类型 
主要实作产品 Clang、GCC 
启发语言 Smalltalk、C 
影响语言 Java、Ruby、TOM 
操作系统 Cross-platform 

Objective-C，通常写作ObjC和较少用的Objective C或Obj-C，是在C的基础上，加入面向对象特性扩充而成的编程语言。

目前，Objective-C主要应用于Mac OS X和iOS这两个NeXTSTEP的衍生系统，而在NeXTSTEP和OpenStep中它更是基本语言。Objective-C可以在任何gcc支持的平台上进行编译，因为gcc原生支持Objective-C。

目录 [隐藏] 
1 历史
2 语法 
2.1 Hello World
2.2 讯息传递
2.3 类的宣告与实现 
2.3.1 Interface
2.3.2 Implementation
2.3.3 创建物件
2.4 协议
2.5 动态类型
2.6 转发 
2.6.1 例子
2.6.2 脚注
2.7 类别 
2.7.1 使用类别的例子
2.7.2 注释
2.8 扮演
2.9 #import
3 语言变化 
3.1 Objective-C++
3.2 Objective-C 2.0 
3.2.1 垃圾收集
3.2.2 属性
3.2.3 快速枚举
4 语言分析
5 参考资料
6 外部连结
 

[编辑] 历史1980年代初，布莱德·确斯（Brad Cox）在其公司Stepstone发明Objective-C，它以一种叫做SmallTalk-80的语言为基础。Objective-C建立在C语言之上，意味着它是在C语言基础上添加了扩展而创造出来的能够创建和操作对象的一门新的程序设计语言。对Objective-C最主要的描述是他1986年出版的《Object-oriented Programming, An Evolutionary Approach》。1988年，NeXT Software公司获得了Objective-C语言的授权，并开发出了Objective-C的语言库和一个名为NEXTSTEP的开发环境。1992年，自由软件基金会的GNU开发环境增加了对Objective-C的支持。1994年，NeXT Computer公司和升阳微系统（Sun Microsystem）联合发布了一个针对NEXTSTEP系统的标准典范，名为OPENSTEP。OPENSTEP在自由软件基金会的实现名称为GNUStep。1996年12月20日，苹果公司宣布收购NeXT Software公司，NEXTSTEP/OPENSTEP环境成为苹果操作系统下一个主要发行版本OS X的基础。这个开发环境的该版本被苹果公司称为Cocoa。

[编辑] 语法Objective-C是C语言的严格母集合，意指任何原始的C语言程式都可以通过Objective-C编译器而不需修改，也允许 Objective-C 使用任何原始的C语言代码。Objective-C 形容自己为覆盖于C语言上的一层薄纱，这是因为Objective-C的原意就是在原始C语言主体上加入面向对象的特性。Objective-C的面向对象语法源于Smalltalk讯息传递风格。所有其他非面向对象的语法，包括变量型别，前处理器（preprocessing），流程控制，函数声明与调用皆与C语言完全一致。

[编辑] Hello World这里示范了一个基础的Hello World程序。

#import<Foundation/Foundation.h>
 
int main(int argc, char *argv[]){
    NSAutoreleasePool * pool = [[NSAutoreleasePool alloc] init];
 
    NSLog(@"Hello World!");
 
    [pool drain];
    return 0;
}
以上是Xcode的旧版"Hello World"程序代码，最新的4.3.1 xcode的代码为:

#import <Foundation/Foundation.h>
 
int main(int argc, char *argv[]){
    @autoreleasepool{
        NSLog(@"Hello World!");
    }
  return 0;
}
[编辑] 讯息传递Objective-C 面向对象最大的特色是的讯息传递（message passing）模型。Objective-C里，物件不呼叫方法，而是互相传递讯息，这与今日的主流C++式面向对象风格差异甚大。此二种风格的差异主要在于程序如何看待呼叫方法/传送讯息这个动作。C++里类与方法的关系非常严格清楚，一个方法必定属于一个类，且于编译期（compile time）就已经紧密绑在一起，你不可能呼叫一个不存在类里的方法。但在Objective-C，类与讯息的关系较为松散，所有方法都被视为对讯息的回应，而呼叫方法则视为对类发送讯息。所有讯息处理直到执行期（runtime）才会动态决定，并交由类自行决定如何处理收到的讯息。也就是说，一个类不保证一定会回应收到的讯息，如果类收到了一个无法处理的讯息，程式并不会出错或当掉，它只会抛出一个Exception。

C++里，送一个讯息给物件（或者说呼叫一个方法）的语法如下：

obj->method(argument);
Objective-C则写成：

[obj method: argument];
此二者并不仅仅是语法上的差异，还有基本行为上的不同。

这里以一个汽车类（car class）的简单例子来解释Objective-C的讯息传递特性：

[car fly];
典型的C++意义解读是“呼叫car类的fly方法”。若car类里头没有定义fly方法，那编译肯定不会通过。但是Objective-C里，我们应当解读为“发送出一个fly的讯息给car物件”，fly是讯息，而car是讯息的接收者。car收到讯息后会决定如何回应这个讯息，若car类内定义有fly方法就执行此段程式，若car内不存在fly方法，这里不会产生编译错误或运行时错误，它仅仅是什么都不做，返回一个nil。

此二种风格各有优劣。C++的面向对象风格支持多重继承，编译期绑定使得函数呼叫非常快速，强制要求所有的方法都必须有对应的动作。缺点是不支持动态绑定（除非手动加上virtual关键字）。Objective-C允许传送未知的讯息给物件，执行期才处理讯息。例如你可以送讯息给整个物件集合而不需要一一检查每个物件的型态，甚至传送讯息给nil也不用担心造成程序崩溃。

Objective-C的方法呼叫因为执行期才动态解析讯息，一开始讯息比C++ virtual成员函数呼叫速度慢上三倍。但经由IMP快取改善，目前已经比C++的virtual function快上50％。

[编辑] 类的宣告与实现Objective-C 类要求分割接口（interface）与实现（implementation）为两个代码区块，这是强制性的。

通常类的接口会放置于标头档内，依C语言的惯例以.h作为副档名；类的实现则放于代码档以.m为副档名。

[编辑] Interface接口区段里头清楚定义了类的名称，实体变量（instance variable），以及方法。 以关键字@interface作为区段起头，@end结束区段。

@interface MyObject : NSObject {
    int memberVar1; // 實體變數
    id  memberVar2;
}
+(return_type) class_method;            // 類方法
 
-(return_type) instance_method1;        // 實體方法
-(return_type) instance_method2: (int) p1;
-(return_type) instance_method3: (int) p1 andPar: (int) p2;
@end
方法前面的+/-号代表方法的类型：加号（+）代表类方法（class method），不需要实体就可以呼叫，近于C++的静态成员函数（static member function）。减号（-）即是一般的实体方法（instance method）。 这里提供了一份意义相近的C++语法对照，如下：

class MyObject : public NSObject {
    int memberVar1;  // 實體變數
    void * memberVar2;
 
  public:
    static return_type class_method(); // 類方法
 
    return_type instance_method1();    // 實體方法
    return_type instance_method2( int p1 );
    return_type instance_method3( int p1, int p2 );
}
Objective-C定义一个新的方法时，名称内的冒号（:）代表参数传递，不同于其他语言以数学函数的括号来传递参数。这使得Objective-C方法的参数不必全部都附缀于方法名称的尾端，也可以夹杂于名称中间，提高代码可读性。以一个设定颜色RGB值的方法为例:

- (void) setColorToRed: (float)red Green: (float)green Blue:(float)blue; /* 宣告方法 */
 
[myColor setColorToRed: 1.0 Green: 0.8 Blue: 0.2]; /* 呼叫方法 */
这个方法的全名是setColorToRed:Green:Blue:。每个冒号后面都带着一个形态为float的参数，分别代表红，绿，蓝三色。

[编辑] Implementation实现区段则撰写方法的实际运行代码。以关键字@implementation作为区段起头，@end结尾。

@implementation MyObject
 
+(return_type) class_method {
    .... //method implementation
}
-(return_type) instance_method1 {
     ....
}
-(return_type) instance_method2: (int) p1 {
    ....
}
-(return_type) instance_method3: (int) p1 andPar: (int) p2 {
    ....
}
@end
[编辑] 创建物件Objective-C建立物件需透过两个讯息：alloc以及init。alloc的作用是分派内存空间，init则是对物件做初始化。 init与alloc都是定义在NSObject里的类方法，当物件收到这两个讯息并做出正确回应后，新实体才算准备妥当。以下即为范例：

MyObject * my = [[MyObject alloc] init];
在Objective-C 2.0里，可以简化为单独一个讯息new

MyObject * my = [MyObject new];
这仅仅是语法上的精简，效用完全相同。 若要自己定义初始化的过程，可以复写init方法，来添加额外的工作。(功用类似C++的constructor)

- (id) init {
    if ( self=[super init] ){   // 必須呼叫父類的init
        // do something here ...
    }
    return self;
}
[编辑] 协议Objective-C在NeXT时期曾经试图引入多重继承的概念，但由于协议的出现而没有实现之。协议的功能类似于C++中对抽象基类的多重继承或是类似Java与C#中的“接口”。在Objective-C中，包括两种定义协议的方式：为特定目的设定的“非正式协议”，以及由编译器保证的“正式协议”。

非正式协议即为一个类可以选择性实现的一系列方法的列表。由于它的定义并没有在程序中出现，它的定义通常在文档中给出。非正式协议通常包含可选的方法，实现这些方法可以使某个类的行为改变。例如文本框类通常会包括一个委托对象，该对象可以实现一个非正式协议，该协议中可能包含一个可选的、用于实现用户输入的自动完成的方法。若这个委托对象实现了这个方法（通过反射，那么文本框类就会在适当的时候调用这个方法用于支持自动完成功能。

正式协议则类似于Java中的"接口"，它是一系列方法的列表，任何类都可以声明自身实现了某一个或一些协议。在Objective-C 2.0之前，一个类必须实现它声明符合的协议中的所有方法，否则编译器会报告一个错误，表明这个类没有实现它声明符合的协议中的全部方法。Objective-C 2.0版本允许标记协议中某些方法为可选的，这样编译器就不会强制实现这些可选的方法。

Objective-C中协议的概念与Java中接口的概念有所不同，即一个类可以在不声明它符合某个协议的情况下，实现这个协议所包含的方法，也即实质上符合这个协议，而这种差别对外部代码而言是不可见的。正式协议的声明不提供实现，它只是简单的对调用者假定符合该协议的类实现了该协议的方法。

语法

@protocol Locking
- (void)lock;
- (void)unlock;
@end
表明有“锁”的抽象观念。以下声明表明了这个类实现了协议Locking：

@interface SomeClass : SomeSuperClass <Locking>
@end
SomeClass的实例声明它提供了Locking协议中的两个方法的实现，无论其语义如何。插件是另一个使用抽象定义的例子，可以在不关心插件的实现的情况下定义其希望的行为。

[编辑] 动态类型类似于Smalltalk，Objective-C支持动态类型：消息可以发送向任意的类实例，而该实例的类型不一定要与定义相符。这种特性可以增加语言的灵活性，因为它允许对象“捕捉”消息，再将消息转送到另一个可以正确处理该消息的对象，或者将消息“转发”给另一个对象。这种行为被称为“消息转发”或“委托”（见下文)。同时，在消息无法被转发的情况下，可能会产生一个错误。若对象不能响应、转发消息或产生错误，该消息会被丢弃而不产生任何信息。因此，若对“nil”（空对象指针）发送消息，该消息会被忽略或产生错误，取决于编译器选项。

静态类型信息也可以应用到变量上，这些信息会在编译期被检查。以下三种声明提供了一个比一个明显的类型信息。这三种声明在运行时是等同的，但附加的类型信息允许编译器在编译时检查变量类型，并在类型不符的情况下提出警告。

- setMyValue:(id) foo;
该声明表示“foo”可以是任何类的实例。

- setMyValue:(id <aProtocol>) foo;
该声明表示“foo”可以是任何类的实例，但它必须符合“aProtocol”协议。

- setMyValue:(NSNumber*) foo;
该声明表示“foo”必须是“NSNumber”的实例。

动态类型是一种强大的特性。利用缺少泛型的静态类型语言（类似Java 5以前的版本）实现容器类时，程序员需要写一种针对通用类型对象的容器类，然后在通用类型和实际类型中不停的进行强制类型转换。无论如何，类型转换不符合静态类型的准则，例如写入一个“整数”而将其读取为“字符串”会产生运行时错误。这样的问题被泛型所解决，但容器类需要其内容对象的类型一致，而对于动态类型语言则完全没有这方面的问题。

[编辑] 转发Objective-C允许对一个对象发送消息，不管它是否能够响应之。除了响应或丢弃消息以外，对象也可以将消息转发到可以响应该消息的对象。转发可以用于简化特定的设计模式，例如观测器模式或代理模式。

Objective-C运行时在Object中定义了一对方法：

转发方法:
- (retval_t) forward:(SEL) sel :(arglist_t) args; // with GCC
- (id) forward:(SEL) sel :(marg_list) args; // with NeXT/Apple systems
响应方法:
- (retval_t) performv:(SEL) sel :(arglist_t) args;  // with GCC
- (id) performv:(SEL) sel :(marg_list) args; // with NeXT/Apple systems
希望实现转发的对象只需用新的方法覆盖以上方法来定义其转发行为。无需重写响应方法performv::，由于该方法只是单纯的对响应对象发送消息并传递参数。其中，SEL类型是Objective-C中消息的类型。

[编辑] 例子这里包括了一个演示转发的基本概念的程序示例。

Forwarder.h
#import <objc/Object.h>
 
@interface Forwarder : Object
{
    id recipient; //该对象是我们希望转发到的对象。
}
 
@property (assign, nonatomic) id recipient;
 
@end
Forwarder.m
#import "Forwarder.h"
 
@implementation Forwarder
 
@synthesize recipient;
 
- (retval_t) forward: (SEL) sel : (arglist_t) args
{
    /*
     *检查转发对象是否响应该消息。
     *若转发对象不响应该消息，则不会转发，而产生一个错误。
     */
    if([recipient respondsTo:sel])
       return [recipient performv: sel : args];
    else
       return [self error:"Recipient does not respond"];
}
Recipient.h
#import <objc/Object.h>
 
// A simple Recipient object.
@interface Recipient : Object
- (id) hello;
@end
Recipient.m
#import "Recipient.h"
 
@implementation Recipient
 
- (id) hello
{
    printf("Recipient says hello!\n");
 
    return self;
}
 
@end
main.m
#import "Forwarder.h"
#import "Recipient.h"
 
int main(void)
{
    Forwarder *forwarder = [Forwarder new];
    Recipient *recipient = [Recipient new];
 
    forwarder.recipient = recipient; //Set the recipient.
    /*
     *转发者不响应hello消息！该消息将被转发到转发对象。
     * (若转发对象响应该消息)
     */
    [forwarder hello];
 
    return 0;
}
[编辑] 脚注利用GCC编译时，编译器报告：

$ gcc -x objective-c -Wno-import Forwarder.m Recipient.m main.m -lobjc
main.m: In function `main':
main.m:12: warning: `Forwarder' does not respond to `hello'
$
如前文所提到的，编译器报告Forwarder类不响应hello消息。在这种情况下，由于实现了转发，可以忽略这个警告。 运行该程序产生如下输出：

$ ./a.out
Recipient says hello!
[编辑] 类别在Objective-C的设计中，一个主要的考虑即为大型代码框架的维护。结构化编程的经验显示，改进代码的一种主要方法即为将其分解为更小的片段。Objective-C借用并扩展了Smalltalk实现中的“类别”概念，用以帮助达到分解代码的目的。[1]

一个类别可以将方法的实现分解进一系列分离的文件。程序员可以将一组相关的方法放进一个类别，使程序更具可读性。举例来讲，可以在字符串类中增加一个名为“拼写检查”的类别，并将拼写检查的相关代码放进这个类别中。

进一步的，类别中的方法是在运行时被加入类中的，这一特性允许程序员向现存的类中增加方法，而无需持有原有的代码，或是重新编译原有的类。例如若系统提供的字符串类的实现中不包含拼写检查的功能，可以增加这样的功能而无需更改原有的字符串类的代码。

在运行时，类别中的方法与类原有的方法并无区别，其代码可以存取包括私有类成员变量在内的所有成员变量。

若类别声明了与类中原有方法同名的函数，则类别中的方法会被调用。因此类别不仅可以增加类的方法，也可以代替原有的方法。这个特性可以用于修正原有代码中的错误，更可以从根本上改变程序中原有类的行为。若两个类别中的方法同名，则被调用的方法是不可预测的。

其它语言也尝试了通过不同方法增加这一语言特性。TOM在这方面走的更远，不仅允许增加方法，更允许增加成员变量。也有其它语言使用面向声明的解决方案，其中最值得注意的是Self语言。

C#与Visual Basic.NET语言以扩展函数的与不完全类的方式实现了类似的功能。Ruby与一些动态语言则以"monkey patch"的名字称呼这种技术。

[编辑] 使用类别的例子这个例子建立了Integer类，其本身只定义了integer属性，然后增加了两个类别Arithmetic与Display以扩展类的功能。虽然类别可以访问类的私有成员，但通常利用属性的存取方法来存取是一种更好的做法，可以使得类别与原有类更加独立。这是类别的一种典型应用—另外的应用是利用类别来替换原有类中的方法，虽然用类别而不是继承来替换方法不被认为是一种好的做法。

Integer.h
#import <objc/Object.h>
 
@interface Integer : Object
{
@private
    int integer;
}
 
@property (assign, nonatomic) integer;
 
@end
Integer.m
#import "Integer.h"
 
@implementation Integer
 
@synthesize integer;
 
@end
Arithmetic.h
#import "Integer.h"
 
@interface Integer (Arithmetic)
- (id) add: (Integer *) addend;
- (id) sub: (Integer *) subtrahend;
@end
Arithmetic.m
#import "Arithmetic.h"
 
@implementation Integer (Arithmetic)
- (id) add: (Integer *) addend
{
    self.integer = self.integer + addend.integer;
    return self;
}
 
- (id) sub: (Integer *) subtrahend
{
    self.integer = self.integer - subtrahend.integer;
    return self;
}
@end
Display.h
#import "Integer.h"
 
@interface Integer (Display)
- (id) showstars;
- (id) showint;
@end
Display.m
#import "Display.h"
 
@implementation Integer (Display)
- (id) showstars
{
    int i, x = self.integer;
    for(i=0; i < x; i++)
       printf("*");
    printf("\n");
 
    return self;
}
 
- (id) showint
{
    printf("%d\n", self.integer);
 
    return self;
}
@end
main.m
#import "Integer.h"
#import "Arithmetic.h"
#import "Display.h"
 
int
main(void)
{
    Integer *num1 = [Integer new], *num2 = [Integer new];
    int x;
 
    printf("Enter an integer: ");
    scanf("%d", &x);
 
    num1.integer = x;
    [num1 showstars];
 
    printf("Enter an integer: ");
    scanf("%d", &x);
 
    num2.integer = x;
    [num2 showstars];
 
    [num1 add:num2];
    [num1 showint];
 
    return 0;
}
[编辑] 注释可以利用以下命令来编译：

gcc -x objective-c main.m Integer.m Arithmetic.m Display.m -lobjc
在编译时间，可以利用省略#import "Arithmetic.h" 与[num1 add:num2]命令，以及Arithmetic.m文件来实验。程序仍然可以运行，这表明了允许动态的、按需的加载类别；若不需要某一类别提供的功能，可以简单的不编译之。

[编辑] 扮演Objective-C允许一个类在程序中完全取代另一个类，这种行为称为前者“扮演”目标类。

注意：类的扮演在Mac OS X v10.5中被废弃，在64位运行时中不可用。

[编辑] #import在C语言中，#include预处理指令总是使被包含的文件内容被插入指令点。在Objective-C中，类似的指令#import保证一个文件只会被包含一次，类似于一般头文件中的

#ifndef XXX
#define XXX ...
#endif
惯用法，或MSVC中的

#pragma once
[编辑] 语言变化[编辑] Objective-C++Objective-C++是GCC的一个前端，它可以编译混合了C++与Objective-C语法的源文件。Objective-C++是C++的扩展，类似于Objective-C是C的扩展。由于在融合C++与Objective-C两种语言的特性方面没有做特别的工作，因此有以下限制：

C++类不能从Objective-C类继承，反之亦然。
Objective-C定义内部不能定义C++命名空间。
Objective-C类的成员变量不能包括不含默认构造函数和/或含有虚方法的C++类对象，但使用C++类指针并无如此限制（可以在 -init方法中对之进行初始化）。
C++“传递值”的特性不能用在Objective-C对象上，而只能传递其指针。
Objective-C声明不能存在在C++模板声明中，反之亦然。但Objective-C类型可以用在C++模板的参数中。
Objective-C和C++的错误处理语句不同，各自的语句只能处理各自的错误。
Objective-C错误使得C++对象被退出时，C++析构函数不会被调用。新的64位运行时解决了这个问题。[2]
[编辑] Objective-C 2.0在2006年苹果全球开发者会议中，Apple宣布了“Objective-C 2.0”的发布，其增加了“现代的垃圾收集，语法改进[3]，运行时性能改进[4]，以及64位支持”。2007年10月发布的Mac OS X v10.5中包含了Objective-C 2.0的编译器。

[编辑] 垃圾收集Objective-C 2.0提供了一个可选的垃圾收集器。在向后兼容模式中，Objective-C运行时会将引用计数操作，例如“retain”与“release”变为无操作。当垃圾收集启用时，所有的对象都是收集器的工作对象。普通的C指针可以以“__strong”修饰，标记指针指向的对象仍在使用中。被标记为“__weak”的指针不被计入收集器的计数中，并在对象被回收时改写为“nil”。iOS上的Objective-C 2.0实现中不包含垃圾收集器。垃圾收集器运行在一个低优先级的后台线程中，并可以在用户动作时暂停，从而保持良好的用户体验。[5]

[编辑] 属性Objective-C 2.0引入了新的语法以声明变量为属性，并包含一可选定义以配置存取方法的生成。属性总是为公共的，其目的为提供外部类存取（也可能为只读）类的内部变量的方法。属性可以被声明为“readonly”，即只读的，也可以提供储存方法包括“assign”，“copy”或“retain”（简单的赋值、复制或增加1引用计数）。默认的属性是原子的，即在访问时会加锁以避免多线程同时访问同一对象，也可以将属性声明为“nonatomic”（非原子的），避免产生锁。

@interface Person : NSObject {
    @public
        NSString *name;
    @private
        int age;
}
 
@property(copy) NSString *name;
@property(readonly) int age;
 
-(id)initWithAge:(int)age;
@end
属性的存取方法由@synthesize关键字来实现，它由属性的声明自动的产生一对存取方法。另外，也可以选择使用@dynamic关键字表明存取方法会由程序员手工提供。

@implementation Person
@synthesize name;
@dynamic age;
 
-(id)initWithAge:(int)initAge
{
    age = initAge; // 注意：直接赋给成员变量，而非属性
    return self;
}
 
-(int)age
{
    return 29; // 注意：并非返回真正的年龄
}
@end
属性可以利用传统的消息表达式、点表达式或"valueForKey:"/"setValue:forKey:"方法对来存取。

Person *aPerson = [[Person alloc] initWithAge: 53];
aPerson.name = @"Steve"; // 注意：点表达式，等于[aPerson setName: @"Steve"];
NSLog(@"Access by message (%@), dot notation(%@), property name(%@) and direct instance variable access (%@)",
      [aPerson name], aPerson.name, [aPerson valueForKey:@"name"], aPerson->name);
为了利用点表达式来存取实例的属性，需要使用“self”关键字：

-(void) introduceMyselfWithProperties:(BOOL)useGetter
{
    NSLog(@"Hi, my name is %@.", (useGetter ? self.name : name)); // NOTE: getter vs. ivar access
}
类或协议的属性可以被动态的读取。

int i;
int propertyCount = 0;
objc_property_t *propertyList = class_copyPropertyList([aPerson class], &propertyCount);
 
for ( i=0; i < propertyCount; i++ ) {
    objc_property_t *thisProperty = propertyList + i;
    const char* propertyName = property_getName(*thisProperty);
    NSLog(@"Person has a property: '%s'", propertyName);
}
[编辑] 快速枚举比起利用NSEnumerator对象或在集合中依次枚举，Objective-C 2.0提供了快速枚举的语法。在Objective-C 2.0中，以下循环的功能是相等的，但性能特性不同。

// 使用NSEnumerator
NSEnumerator *enumerator = [thePeople objectEnumerator];
Person *p;
 
while ( (p = [enumerator nextObject]) != nil ) {
    NSLog(@"%@ is %i years old.", [p name], [p age]);
}
// 使用依次枚举
for ( int i = 0; i < [thePeople count]; i++ ) {
    Person *p = [thePeople objectAtIndex:i];
    NSLog(@"%@ is %i years old.", [p name], [p age]);
}
// 使用快速枚举
for (Person *p in thePeople) {
    NSLog(@"%@ is %i years old.", [p name], [p age]);
}
快速枚举可以比标准枚举产生更有效的代码，由于枚举所调用的方法被使用NSFastEnumeration协议提供的指针算术运算所代替了。[6]

[编辑] 语言分析Objective-C是非常“实际”的语言。它用一个很小的、用C写成的运行库，使得应用程式的大小增加很少，与此相比，大部分OO系统需要极大的运行时虚拟机来执行。ObjC写成的程式通常不会比其源代码和函式库（通常无需包含在软件发行版本中）大太多，不会像Smalltalk系统，即使只是打开一个窗口也需要大量的容量。由于Obj-C的动态类型特征，Obj-C不能对方法进行内联（inline）一类的优化，使得Obj-C的应用程序一般比类似的C或C++程序更小。

Obj-C可以在现存C编译器基础上实现（在GCC中，Obj-C最初作为预处理器引入，后来作为模块存在），而不需要编写一个全新的编译器。这个特性使得Obj-C能利用大量现存的C代码、库、工具和编程思想等资源。现存C库可以用Obj-C包装器来提供一个Obj-C使用的OO风格界面包装。

以上这些特性极大地降低了进入Obj-C的门槛，这是1980年代Smalltalk在推广中遇到的最大问题。

Objective-C的最初版本并不支持垃圾回收（garbage collection）。在当时这是争论的焦点之一，很多人考虑到Smalltalk回收时有漫长的“死亡时间”，令整个系统失去功用，Objective-C为避免此问题才不拥有这个功能。某些第三方版本加入了这个功能（尤是GNUstep），苹果公司也在其Mac OS X 10.5中提供了实现。

另一个广受批评的问题是ObjC不包括命名空间机制（namespace mechanism）。取而代之的是程式设计师必须在其类别名称加上前缀，由于前缀往往较短（相比命名空间），这时常引致冲突。在2007年，在Cocoa编程环境中，所有Mac OS X类别和函式均有“NS”作为前缀，例如NSObject或NSButton来清楚分辨它们属于Mac OS X核心；使用“NS”是由于这些类别的名称在NeXTSTEP开发时定下。

虽然Objective-C是C的严格超集，但它也不视C的基本类型为第一级的对象。

和C++不同，Objective-C不支援运算子多载（它不支持ad-hoc多型）。亦与C++不同，但和Java相同，Objective-C只容许物件继承一个类别（不设多重继承）。Categories和protocols不但可以提供很多多重继承的好处，而且没有很多缺点，例如额外执行时间过重和二进制不兼容。[来源请求]

由于Obj-C使用动态运行时类型，而且所有的方法都是函数调用（有时甚至连系统调用（syscalls）也如此），很多常见的编译时性能优化方法都不能应用于Obj-C（例如：内联函数、常数传播、交互式优化、纯量取代与聚集等）。这使得Obj-C性能劣于类似的对象抽象语言（如C++）。不过Obj-C拥护者认为既然Obj-C运行时消耗较大，Obj-C本来就不应应用于C++或Java常见的底层抽象。