Objective-C 2.0编程指南

需积分: 3 79 浏览量更新于2024-08-02 1 收藏 1.13MB PDF 举报

"The Objective-C 2.0 Programming Language文档提供了Objective-C编程语言的详细指南，由Apple Inc.于2009年发布。该文档涵盖了语言的基础知识、使用工具和编程实践，旨在帮助开发者理解和应用Objective-C进行软件开发。文档强调了对版权的尊重，并指出个人可以出于非商业目的存储和打印文档，但需包含Apple的版权通知。" Objective-C 2.0是Objective-C语言的一个重要版本，它在早期Objective-C的基础上进行了一些改进和增强。这个编程语言主要用于开发苹果平台上的应用程序，包括iOS和macOS。以下是Objective-C 2.0的一些关键知识点： 1. **面向对象编程**：Objective-C基于C语言，添加了面向对象的特性，如类、继承、封装和多态。这些概念使得代码更易于组织和重用。 2. **消息传递**：Objective-C中的对象通过消息传递进行交互，类似于其他语言中的方法调用。发送消息的语法是`[receiver message]`，这允许动态绑定，增强了灵活性。 3. **类别（Category）**：Objective-C允许通过类别给现有的类添加方法，而无需子类化。这在不修改原有类代码的情况下扩展其功能非常有用。 4. **协议（Protocol）**：协议类似于Java或C#的接口，定义了一组方法签名，可以被类实现。它们常用于实现委托设计模式和定义数据源。 5. **块（Block）**：Objective-C 2.0引入了块（Block），这是一种内联函数，可以捕获并存储其定义时的作用域内的变量。块在处理异步任务、事件回调等方面特别有用。 6. **属性（Property）**：Objective-C 2.0增加了属性（Property）的概念，提供了自动内存管理、存取方法生成和KVO（Key-Value Observing）支持。 7. **垃圾回收（Garbage Collection）**：虽然现在已经被ARC（Automatic Reference Counting）取代，但在Objective-C 2.0时代，垃圾回收是一种内存管理机制，用于自动释放不再使用的对象。 8. **内存管理**：ARC是Objective-C 2.0的一大改进，它自动管理对象的生命周期，减少了手动内存管理的错误。然而，理解引用计数的基本原理仍然是必要的。 9. **Foundation框架**：Objective-C的许多基本类和数据结构，如NSArray、NSDictionary、NSString等，都属于Foundation框架，它是开发iOS和macOS应用程序的基础。 10. **Cocoa与Cocoa Touch**：Cocoa是macOS开发的主要框架，Cocoa Touch是iOS开发的框架，它们都是基于Objective-C构建的，提供了一系列工具和类库，简化了用户界面和应用程序逻辑的创建。以上是Objective-C 2.0编程语言的核心知识点，学习和掌握这些内容对于开发苹果平台的应用至关重要。这份文档是深入理解Objective-C语言及其生态系统的重要参考资料。

[receiver message]

The receiver is an object, and the message tells it what to do. In source code, the message is simply the name

of a method and any arguments that are passed to it. When a message is sent, the runtime system selects

the appropriate method from the receiver’s repertoire and invokes it.

For example, this message tells the myRectangle object to perform its display method, which causes the

rectangle to display itself:

[myRectangle display];

The message is followed by a “;” as is normal for any line of code in C.

The method name in a message serves to “select” a method implementation. For this reason, method names

in messages are often referred to as selectors.

Methods can also take parameters, or “arguments.” A message with a single argument affixes a colon (:) to

the selector name and puts the argument right after the colon. This construct is called a keyword; a keyword

ends with a colon, and an argument follows the colon, as shown in this example:

[myRectangle setWidth:20.0];

A selector name includes all keywords, including colons, but does not include anything else, such as return

type or parameter types. The imaginary message below tells the myRectangle object to set its origin to the

coordinates (30.0, 50.0):

[myRectangle setOrigin:30.0 :50.0]; // This is a bad example of multiple arguments

Since the colons are part of the method name, the method is named setOrigin::. It has two colons as it

takes two arguments. This particular method does not interleave the method name with the arguments and,

thus, the second argument is effectively unlabeled and it is difficult to determine the kind or purpose of the

method’s arguments.

Instead, method names should interleave the name with the arguments such that the method's name naturally

describes the arguments expected by the method. For example, the Rectangle class could instead implement

a setOriginX:y: method that makes the purpose of its two arguments clear:

[myRectangle setOriginX: 30.0 y: 50.0]; // This is a good example of multiple

arguments

Object Messaging

CHAPTER 1

Objects, Classes, and Messaging

Important: The sub-parts of the method name—of the selector—are not optional, nor can their order be

varied. “Named arguments” and “keyword arguments” often carry the implication that the arguments to a

method can vary at runtime, can have default values, can be in a different order, can possibly have additional

named arguments. This is not the case with Objective-C.

For all intents and purposes, an Objective-C method declaration is simply a C function that prepends two

additional arguments (see Messaging in the Objective-C 2.0 Runtime Programming Guide). This is different

from the named or keyword arguments available in a language like Python:

def func(a, b, NeatMode=SuperNeat, Thing=DefaultThing):

pass

where Thing (and NeatMode) might be omitted or might have different values when called.

Methods that take a variable number of arguments are also possible, though they’re somewhat rare. Extra

arguments are separated by commas after the end of the method name. (Unlike colons, the commas aren’t

considered part of the name.) In the following example, the imaginary makeGroup: method is passed one

required argument (group) and three that are optional:

[receiver makeGroup:group, memberOne, memberTwo, memberThree];

Like standard C functions, methods can return values. The following example sets the variable isFilled to

YES if myRectangle is drawn as a solid rectangle, or NO if it’s drawn in outline form only.

BOOL isFilled;

isFilled = [myRectangle isFilled];

Note that a variable and a method can have the same name.

One message expression can be nested inside another. Here, the color of one rectangle is set to the color of

another:

[myRectangle setPrimaryColor:[otherRect primaryColor]];

Objective-C 2.0 also provides a dot (.) operator that offers a compact and convenient syntax for invoking an

object’s accessor methods. This is typically used in conjunction with the declared properties feature (see

“Declared Properties” (page 67)), and is described in “Dot Syntax” (page 20).

Sending Messages to nil

In Objective-C, it is valid to send a message to nil—it simply has no effect at runtime. There are several

patterns in Cocoa that take advantage of this fact. The value returned from a message to nil may also be

valid:

■ If the method returns an object, then a message sent to nil returns 0 (nil), for example:

Person *motherInLaw = [[aPerson spouse] mother];

If aPerson’s spouse is nil, then mother is sent to nil and the method returns nil.

■ If the method returns any pointer type, any integer scalar of size less than or equal to sizeof(void*),

a float, a double, a long double, or a long long, then a message sent to nil returns 0.

Object Messaging 17

CHAPTER 1

Objects, Classes, and Messaging

■ If the method returns a struct, as defined by the Mac OS X ABI Function Call Guide to be returned in

registers, then a message sent to nil returns 0.0 for every field in the data structure. Other struct data

types will not be filled with zeros.

■ If the method returns anything other than the aforementioned value types the return value of a message

sent to nil is undefined.

The following code fragment illustrates valid use of sending a message to nil.

id anObjectMaybeNil = nil;

// this is valid

if ([anObjectMaybeNil methodThatReturnsADouble] == 0.0)

{

// implementation continues...

}

Note: The behavior of sending messages to nil changed slightly with Mac OS X v10.5.

On Mac OS X v10.4 and earlier, a message to nil also is valid, as long as the message returns an object, any

pointer type, void, or any integer scalar of size less than or equal to sizeof(void*); if it does, a message

sent to nil returns nil. If the message sent to nil returns anything other than the aforementioned value

types (for example, if it returns any struct type, any floating-point type, or any vector type) the return value

is undefined. You should therefore not rely on the return value of messages sent to nil unless the method’s

return type is an object, any pointer type, or any integer scalar of size less than or equal to sizeof(void*).

The Receiver’s Instance Variables

A method has automatic access to the receiving object’s instance variables. You don’t need to pass them to

the method as arguments. For example, the primaryColor method illustrated above takes no arguments,

yet it can find the primary color for otherRect and return it. Every method assumes the receiver and its

instance variables, without having to declare them as arguments.

This convention simplifies Objective-C source code. It also supports the way object-oriented programmers

think about objects and messages. Messages are sent to receivers much as letters are delivered to your home.

Message arguments bring information from the outside to the receiver; they don’t need to bring the receiver

to itself.

A method has automatic access only to the receiver’s instance variables. If it requires information about a

variable stored in another object, it must send a message to the object asking it to reveal the contents of

the variable. The primaryColor and isFilled methods shown above are used for just this purpose.

See “Defining a Class” (page 35) for more information on referring to instance variables.

Polymorphism

As the examples above illustrate, messages in Objective-C appear in the same syntactic positions as function

calls in standard C. But, because methods “belong to” an object, messages behave differently than function

calls.

Object Messaging

CHAPTER 1

Objects, Classes, and Messaging

In particular, an object can be operated on by only those methods that were defined for it. It can’t confuse

them with methods defined for other kinds of object, even if another object has a method with the same

name. This means that two objects can respond differently to the same message. For example, each kind of

object sent a display message could display itself in a unique way. A Circle and a Rectangle would respond

differently to identical instructions to track the cursor.

This feature, referred to as polymorphism, plays a significant role in the design of object-oriented programs.

Together with dynamic binding, it permits you to write code that might apply to any number of different

kinds of objects, without you having to choose at the time you write the code what kinds of objects they

might be. They might even be objects that will be developed later, by other programmers working on other

projects. If you write code that sends a display message to an id variable, any object that has a display

method is a potential receiver.

Dynamic Binding

A crucial difference between function calls and messages is that a function and its arguments are joined

together in the compiled code, but a message and a receiving object aren’t united until the program is

running and the message is sent. Therefore, the exact method that’s invoked to respond to a message can

only be determined at runtime, not when the code is compiled.

The precise method that a message invokes depends on the receiver. Different receivers may have different

method implementations for the same method name (polymorphism). For the compiler to find the right

method implementation for a message, it would have to know what kind of object the receiver is—what

class it belongs to. This is information the receiver is able to reveal at runtime when it receives a message

(dynamic typing), but it’s not available from the type declarations found in source code.

The selection of a method implementation happens at runtime. When a message is sent, a runtime messaging

routine looks at the receiver and at the method named in the message. It locates the receiver’s implementation

of a method matching the name, “calls” the method, and passes it a pointer to the receiver’s instance variables.

(For more on this routine, see Messaging in the Objective-C 2.0 Runtime Programming Guide.)

This dynamic binding of methods to messages works hand-in-hand with polymorphism to give object-oriented

programming much of its flexibility and power. Since each object can have its own version of a method, a

program can achieve a variety of results, not by varying the message itself, but by varying just the object

that receives the message. This can be done as the program runs; receivers can be decided “on the fly” and

can be made dependent on external factors such as user actions.

When executing code based upon the Application Kit, for example, users determine which objects receive

messages from menu commands like Cut, Copy, and Paste. The message goes to whatever object controls

the current selection. An object that displays text would react to a copy message differently from an object

that displays scanned images. An object that represents a set of shapes would respond differently from a

Rectangle. Since messages don’t select methods (methods aren’t bound to messages) until runtime, these

differences are isolated in the methods that respond to the message. The code that sends the message

doesn’t have to be concerned with them; it doesn’t even have to enumerate the possibilities. Each application

can invent its own objects that respond in their own way to copy messages.

Objective-C takes dynamic binding one step further and allows even the message that’s sent (the method

selector) to be a variable that’s determined at runtime. This is discussed in the section Messaging in the

Objective-C 2.0 Runtime Programming Guide.

Object Messaging 19

CHAPTER 1

Objects, Classes, and Messaging

剩余132页未读，继续阅读

ruanxf

粉丝: 1
资源: 1

Objective-C 2.0编程指南

Objective-C - Learning Objective-C 2.0 Second Edition

Programming in Objective-C 2.0

Objective-C 2.0编程语言详解

Objective-C 2.0 Programming Language

Objective-C 2.0编程语言（Apple Inc.）The Objective-C 2.0 Programming Language (Apple Inc.)

世界各国、全国及分地区长时间序列人口老龄化与抚养比数据-最新出炉.zip

暴风电视刷机 55AI4A 屏LC546PU2L01(熊猫) 机编60000AM0P00 屏参30173307 V1.0.74

【JCR一区级】Matlab实现被囊群优化算法TSA-CNN-LSTM-Attention的故障诊断算法研究.rar

2005-2022年中国企业OFDI微观数据-最新出炉.zip

Python中os模块的常用方法和示例（含完整的程序和代码详解）

最新资源