Objective-C 2.0编程指南：iOS开发者必备

3星 · 超过75%的资源需积分: 0 133 浏览量更新于2024-07-27 收藏 1.24MB PDF 举报

Objective-C第二版编程语言教程是iOS开发者不可或缺的学习资料，它由Apple Inc.于2008年发布。该文档详细介绍了Objective-C 2.0语言，这是Cocoa框架的核心，是苹果公司为编写Mac OS X和iOS应用的主要编程语言。Objective-C是一种结合了C语言和Smalltalk面向对象特性（Objective）的语言，它的设计旨在提供高效、灵活且易于维护的编程环境。在文档中，学习者可以深入了解Objective-C的基础知识，包括类与对象、继承、消息传递机制（message passing）、 Category和Block等核心概念。Objective-C允许程序员通过Objective-C类来组织代码，这些类提供了封装、继承和多态的特性，有助于构建复杂的应用程序结构。 Cocoa框架是Objective-C的重要组成部分，它提供了一系列的工具和类库，如UIKit（用于iOS应用界面开发）和AppKit（用于Mac OS X界面）。通过Cocoa，开发者能够利用Objective-C来创建图形用户界面（GUI），以及处理网络通信、多媒体操作、数据库访问等任务。文档强调了版权和许可的重要性，规定了复制、存储和传播文档的条件，除非得到Apple Inc.的书面许可，否则不能进行任何形式的商业用途，以防止侵犯商标权和不公平竞争。此外，尽管文档提供了技术指导，但并不授予任何技术许可，Apple公司仍保留所有与此技术相关的知识产权。对于希望进入iOS开发领域的人来说，Objective-C第二版编程语言教程是入门和进阶学习的基石，它帮助开发者掌握iOS应用开发的基础语法、设计模式和最佳实践，以便创造出高效、易用且具有竞争力的移动应用程序。随着学习的深入，读者将能够熟练地运用Objective-C语言和Cocoa框架，为iOS平台创造创新的用户体验。

For the object-oriented constructs of Objective-C, such as method return values, id replaces int as

the default data type. (For strictly C constructs, such as function return values, int remains the default

type.)

The keyword nil is defined as a null object, an id with a value of 0. id, nil, and the other basic types

of Objective-C are defined in the header file objc/objc.h.

Dynamic Typing

The id type is completely nonrestrictive. By itself, it yields no information about an object, except

that it is an object.

But objects aren’t all the same. A Rectangle won’t have the same methods or instance variables as an

object that represents a bit-mapped image. At some point, a program needs to find more specific

information about the objects it contains—what the object’s instance variables are, what methods it

can perform, and so on. Since the id type designator can’t supply this information to the compiler,

each object has to be able to supply it at runtime.

This is possible because every object carries with it an isa instance variable that identifies the object’s

class—what kind of object it is. Every Rectangle object would be able to tell the runtime system that

it is a Rectangle. Every Circle can say that it is a Circle. Objects with the same behavior (methods)

and the same kinds of data (instance variables) are members of the same class.

Objects are thus dynamically typed at runtime. Whenever it needs to, the runtime system can find

the exact class that an object belongs to, just by asking the object. Dynamic typing in Objective-C

serves as the foundation for dynamic binding, discussed later.

The isa pointer also enables objects to perform introspection—to find out about themselves (or other

objects). The compiler records information about class definitions in data structures for the runtime

system to use. The functions of the runtime system use isa, to find this information at runtime. Using

the runtime system, you can, for example, determine whether an object implements a particular

method, or discover the name of its superclass.

Object classes are discussed in more detail under “Classes” (page 20).

It’s also possible to give the compiler information about the class of an object by statically typing it

in source code using the class name. Classes are particular kinds of objects, and the class name can

serve as a type name. See “Class Types” (page 23) and “Enabling Static Behavior” (page 87).

Object Messaging

This section explains the syntax of sending messages, including how you can nest message expressions.

It also discusses the “visibility” of an object’s instance variables, and the concepts of polymorphism

and dynamic binding.

Object Messaging

CHAPTER 1

Objects and Classes

Message Syntax

To get an object to do something, you send it a message telling it to apply a method. In Objective-C,

message expressions are enclosed in brackets:

[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 myRect object to perform its display method, which causes the

rectangle to display itself:

[myRect display];

Methods can also take arguments. The imaginary message below tells myRect to set its location within

the window to coordinates (30.0, 50.0):

[myRect setOrigin:30.0 :50.0];

Here the method name, setOrigin::, has two colons, one for each of its arguments. The arguments

are inserted after the colons. This method name uses unlabeled arguments. Unlabeled arguments

make it difficult to determine the kind and purpose of a method’s arguments. Instead, method names

should include labels describing each of their arguments. Argument labels precede each colon in the

method name. The setWidth:height: method, for example, makes the purpose of its two arguments

clear:

[myRect setWidth:10.0 height:15.0];

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 “Properties” (page 45)), and is described in “The Dot Syntax” (page 54).

Object Messaging 17

CHAPTER 1

Objects and Classes

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.

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 31) for more information on referring to instance variables.

Object Messaging

CHAPTER 1

Objects and Classes

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.

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

Object Messaging 19

CHAPTER 1

Objects and Classes

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

Classes

An object-oriented program is typically built from a variety of objects. A program based on the Cocoa

frameworks might use NSMatrix objects, NSWindow objects, NSDictionary objects, NSFont objects,

NSText objects, and many others. Programs often use more than one object of the same kind or

class—several NSArray objects or NSWindow objects, for example.

In Objective-C, you define objects by defining their class. The class definition is a prototype for a kind

of object; it declares the instance variables that become part of every member of the class, and it defines

a set of methods that all objects in the class can use.

The compiler creates just one accessible object for each class, a class object that knows how to build

new objects belonging to the class. (For this reason it’s traditionally called a “factory object.”) The

class object is the compiled version of the class; the objects it builds are instances of the class. The

objects that do the main work of your program are instances created by the class object at runtime.

All instances of a class have the same set of methods, and they all have a set of instance variables cut

from the same mold. Each object gets its own instance variables, but the methods are shared.

By convention, class names begin with an uppercase letter (such as “Rectangle”); the names of instances

typically begin with a lowercase letter (such as “myRect”).

Inheritance

Class definitions are additive; each new class that you define is based on another class from which it

inherits methods and instance variables. The new class simply adds to or modifies what it inherits.

It doesn’t need to duplicate inherited code.

Inheritance links all classes together in a hierarchical tree with a single class at its root. When writing

code that is based upon the Foundation framework, that root class is typically NSObject. Every class

(except a root class) has a superclass one step nearer the root, and any class (including a root class)

can be the superclass for any number of subclasses one step farther from the root. Figure 1-1 illustrates

the hierarchy for a few of the classes used in the drawing program.

Classes

CHAPTER 1

Objects and Classes

剩余154页未读，继续阅读

lidongzhuo10

粉丝: 0
资源: 8

Objective-C 2.0编程指南：iOS开发者必备

objective-c编程 第2版=objective-c program 2nd edition_13889311

Objective-C大纲 第一版和第二版

《Objective-C基础教程（第二版）》英文版

iOS编程指南：第二版详解应用开发与Objective-C核心技术

Programming in Objective-C 2.0 第二版

Objective-C 2.0 编程(第四版)

Objective-C编程语言第二版英文PDF

Objective-C 2.0编程第二版：深入解析

Objective-C 2.0英文版编程语言详析

Objective-C 示例：Braintree iOS 支付集成指南

最新资源

objective-c编程第2版=objective-c program 2nd edition_13889311

Objective-C大纲第一版和第二版