Objective-C 2.0编程语言指南：Cocoa核心技术

需积分: 0 102 浏览量更新于2024-07-27 收藏 1.24MB PDF 举报

Objective-C 第二版是一本由 Apple Inc. 出版于 2008 年的编程语言指南，专注于Objective-C 2.0，这是当时的Cocoa框架的核心语言。这本书详细介绍了Objective-C语言的特点、设计原则以及在iOS和Mac OS X平台上的应用。作为C++和Smalltalk的结合体，Objective-C强调了面向对象编程（Object-Oriented Programming, OOP）的概念，包括类、消息传递和继承等特性。书中内容涵盖了以下几个关键知识点： 1. **语言基础**：讲解Objective-C的语法，如类定义、实例化、属性和方法的声明与实现，以及如何使用关键字`@interface`、`@implementation`和`@end`来组织代码结构。 2. **Cocoa框架**：作为Apple开发iOS和Mac OS X应用程序的主要工具包，Cocoa提供了丰富的UI元素和框架支持，如NSManagedObject、Core Data、Foundation框架（如NSArray、NSDictionary等）等，帮助开发者构建高效且用户友好的应用。 3. **Objective-C 2.0新特性**：介绍了Objective-C 2.0版本引入的新功能，比如Blocks（闭包）、Generics（泛型）、Category（分类）等，这些特性扩展了语言的功能，提升了代码的灵活性。 4. **内存管理**：Objective-C的自动引用计数（Automatic Reference Counting, ARC）是2.0版本的重要变化，它简化了内存管理，减少了内存泄漏的风险。 5. **Objective-C运行时**：阐述了Objective-C Runtime，它是Objective-C程序的底层实现，开发者可以通过Runtime动态修改类和对象的行为，实现元编程。 6. **KVC（Key-Value Coding）和KVO（Key-Value Observing）**：这两种机制使得开发者能够通过字符串键名而非类型进行对象属性的访问和观察，提高代码的可读性和灵活性。 7. **设计模式与实践**：书中还涉及了一些面向对象设计原则，如单例模式、工厂模式等，并提供了如何在Objective-C中实现这些设计模式的实际示例。 8. **错误处理和异常处理**：讨论了如何优雅地处理程序运行过程中的错误和异常，确保程序的健壮性。 9. **文档和工具**：书中强调了编写清晰文档的重要性，同时提到了Xcode这样的集成开发环境（IDE），它提供了强大的编辑器、调试工具以及与Objective-C交互的全套支持。由于版权问题，未经Apple Inc. 的书面许可，本书的部分内容不能被复制或传播。苹果公司保留所有关于文中技术的知识产权，并且提醒读者，未经授权的商业使用苹果的商标可能会构成商标侵权和不公平竞争行为。 Objective-C 第二版是一本深入理解Objective-C编程语言和Cocoa框架的必备参考书，对于希望在Apple平台开发软件的开发者来说，它提供了详尽的技术指导和实践经验。

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页未读，继续阅读

Shen_Xue_

粉丝: 0
资源: 1

Objective-C 2.0编程语言指南：Cocoa核心技术

N本ObjectiveC iPhone iOS iPad Mac开发经典书籍PDF打包

Objective-C 思维导图.pdf

无涯教程(LearnFk)-iOS教程离线版.pdf

【Objective-C.Phrasebook.2nd.Edition】[PDF+源代码] [iPhone/iPad/iOS]

Objective-C基础教程(第二版).pdf

Objective-C.2.0程序设计(第二版)带完整书签.pdf

Programming in objective - C.pdf

Objective-C2.0程序设计(原书第二版).pdf.part2(高清最新版)

Objective-C2.0程序设计(原书第二版).pdf.part3(高清最新版)

Objective-C2.0程序设计(原书第二版).pdf.part1(高清最新版)

最新资源