Objective-C 2.0编程语言深度解析

3星 · 超过75%的资源需积分: 9 94 浏览量更新于2024-07-31 收藏 1.29MB PDF 举报

Object-C，一种面向对象的编程语言，是Apple Inc.在2008年发布的Objective-C 2.0版本。该语言的设计初衷是为了增强Objective-C的特性，以便更好地与Apple的Cocoa框架和Foundation框架协同工作，尤其是针对Mac OS X和iOS平台的应用开发。Objective-C结合了C语言的效率和C++的面向对象特性，使其成为iOS应用开发中的主流语言。在Objective-C 2.0中，苹果公司强调了版权保护，所有文档的复制、存储、检索或传输都必须获得书面许可，除非满足个人使用的规定，如单机文档存储备份和个人打印。苹果商标，包括键入快捷键"Option-Shift-K"，在商业用途上使用需经苹果事先书面同意，否则可能构成商标侵权和不公平竞争，违反联邦和州法律。重要的是，Objective-C 2.0引入了一些关键特性。例如，它扩展了Cocoa Foundation框架，支持自动引用计数（ARC），这是一个内存管理机制，简化了内存分配和释放过程，降低了内存泄漏的风险。此外，语言引入了Block（闭包）的概念，这是一种轻量级的代码块，可以在不创建新线程的情况下执行，提升了多线程编程的灵活性。 Objective-C 2.0还加强了面向对象编程的支持，包括分类（Categories）和协议（Protocols），使得开发者可以动态地扩展现有类的功能，以及实现多态性。Objective-C的继承机制允许子类继承父类的方法和属性，并通过消息传递机制调用它们。文档的主要目的是为了帮助应用程序开发者更好地利用Objective-C进行高效、可维护的软件开发，确保遵循苹果的指导原则，以便在iOS和Mac平台上创建出高质量的应用程序。通过学习和理解Objective-C 2.0的特性，开发者可以充分利用其强大功能，提升开发效率，同时保持对知识产权的尊重。

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 “How Messaging Works” (page 75)). 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 myRect is drawn as a solid rectangle, or NO if it’s drawn in outline form only.

BOOL isFilled;

isFilled = [myRect 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:

[myRect 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 49)), and is described in “Dot Syntax” (page 18).

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, 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.

■

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.

Object Messaging

CHAPTER 1

Objects and Classes

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 with Mac OS X v10.5; for the behavior of

previous versions, see prior documentation.

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.

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 objects, 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.

Object Messaging 17

CHAPTER 1

Objects and Classes

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 “How Messaging Works” (page

75).)

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

method names in messages are often referred to as selectors.

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 “How

Messaging Works” (page 75).

Dot Syntax

Objective-C provides a dot (.) operator that offers a compact and convenient syntax you can use as

an alternative to square bracket notation ([]s) to invoke accessor methods. It is particularly useful

when you want to access or modify a property that is a property of another object (that is a property

of another object, and so on).

Object Messaging

CHAPTER 1

Objects and Classes

Using the Dot Syntax

Overview

You can use the dot syntax to invoke accessor methods using the same pattern as accessing structure

elements as illustrated in the following example:

myInstance.value = @"New value";

NSLog(@"myInstance value: %@", myInstance.value);

The dot syntax is purely “syntactic sugar”—it is transformed by the compiler into invocation of

accessor methods (so you are not actually accessing an instance variable directly). The code example

above is exactly equivalent to the following:

[myInstance setValue:@"New value"];

NSLog(@"myInstance value: %@", [myInstance value]);

General Use

You can read and write properties using the dot (.) operator, as illustrated in the following example.

Listing 1-1 Accessing properties using the dot syntax

Graphic *graphic = [[Graphic alloc] init];

NSColor *color = graphic.color;

CGFloat xLoc = graphic.xLoc;

BOOL hidden = graphic.hidden;

int textCharacterLength = graphic.text.length;

if (graphic.textHidden != YES) {

graphic.text = @"Hello";

}

graphic.bounds = NSMakeRect(10.0, 10.0, 20.0, 120.0);

Accessing a property property calls the get method associated with the property (by default, property)

and setting it calls the set method associated with the property (by default, setProperty:). You can

change the methods that are invoked by using the Declared Properties feature (see “Declared

Properties” (page 49)). Despite appearances to the contrary, the dot syntax therefore preserves

encapsulation—you are not accessing an instance variable directly.

The following statements compile to exactly the same code as the statements shown in “Accessing

properties using the dot syntax” (page $@), but use square bracket syntax:

Listing 1-2 Accessing properties using accessor methods

Graphic *graphic = [[Graphic alloc] init];

NSColor *color = [graphic color];

CGFloat xLoc = [graphic xLoc];

BOOL hidden = [graphic hidden];

int textCharacterLength = [[graphic text] length];

if ([graphic isTextHidden] != YES) {

[graphic setText:@"Hello"];

Object Messaging 19

CHAPTER 1

Objects and Classes

}

[graphic setBounds:NSMakeRect(10.0, 10.0, 20.0, 120.0)];

An advantage of the dot syntax is that the compiler can signal an error when it detects a write to a

read-only property, whereas at best it can only generate an undeclared method warning that you

invoked a non-existent setProperty: method, which will fail at runtime.

For properties of the appropriate C language type, the meaning of compound assignments is

well-defined. For example, you could update the length property of an instance of NSMutableData

using compound assignments:

NSMutableData *data = [NSMutableData dataWithLength:1024];

data.length += 1024;

data.length *= 2;

data.length /= 4;

which is equivalent to:

[data setLength:[data length] + 1024];

[data setLength:[data length] * 2];

[data setLength:[data length] / 4];

There is one case where properties cannot be used. Consider the following code fragment:

id y;

x = y.z; // z is an undeclared property

Note that y is untyped and the z property is undeclared. There are several ways in which this could

be interpreted. Since this is ambiguous, the statement is treated as an undeclared property error. If z

is declared, then it is not ambiguous if there's only one declaration of a z property in the current

compilation unit. If there are multiple declarations of a z property, as long as they all have the same

type (such as BOOL) then it is legal. One source of ambiguity would also arise from one of them being

declared readonly.

nil Values

If a nil value is encountered during property traversal, the result is the same as sending the equivalent

message to nil. For example, the following pairs are all equivalent:

// each member of the path is an object

x = person.address.street.name;

x = [[[person address] street] name];

// the path contains a C struct

// will crash if window is nil or -contentView returns nil

y = window.contentView.bounds.origin.y;

y = [[window contentView] bounds].origin.y;

// an example of using a setter....

person.address.street.name = @"Oxford Road";

[[[person address] street] setName: @"Oxford Road"];

self

If you want to access a property of self using accessor methods, you must explicitly call out self

as illustrated in this example:

Object Messaging

CHAPTER 1

Objects and Classes

剩余146页未读，继续阅读

Symbian_Observer

粉丝: 2
资源: 3

Objective-C 2.0编程语言深度解析

Object-C语言详细学习教程 入门攻略整理面试.docx

Object-C语言教程&案例&相关项目资源（PPT文档）

Object-b资源：利用Object-C语言编写的计数程序

Object-C语言项目实践示例分析

Object-C语言全方位教程与案例分析

如何学习Object-C语言.docx

Object-C语言教程&案例&相关项目资源

基于matlab Object-C语言教程物理应用-代码说明.txt

Object-C语言教程&案例&相关项目.zip

Object-C语言教程0220.zip基础知识及相关案例

最新资源

Object-C语言详细学习教程入门攻略整理面试.docx