Objective-C 2.0编程语言详解

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

"Objective-C+第二版 - 非常不错的Objective-C学习教程" Objective-C是苹果公司开发的一种面向对象的编程语言，它是基于C语言的，同时融入了Smalltalk的特性，广泛应用于iOS和macOS的软件开发。Objective-C 2.0是在原语言基础上进行的一次重大更新，引入了许多改进和优化，旨在提高开发者的效率和代码的可读性。在《Objective-C 2.0 Programming Language》这份文档中，读者可以深入理解Objective-C的核心概念，包括类、对象、消息传递等基本概念。Objective-C中的类是面向对象编程的基础，它们定义了对象的属性和行为；对象则是类的实例，通过消息传递（方法调用）来实现功能。此外，文档还涵盖了命名空间（categories）、协议（protocols）以及动态类型系统等高级主题。 Objective-C中的Cocoa框架是苹果平台开发的关键，它提供了大量的API和工具，使得开发者能够构建出功能丰富的应用程序。Cocoa框架包含了Foundation和AppKit（或UIKit）两大部分，Foundation负责基础的数据管理和系统服务，而AppKit或UIKit则为用户界面提供支持。文档中可能会详细介绍内存管理机制，Objective-C 2.0引入了Automatic Reference Counting (ARC)，自动处理对象的引用计数，极大地简化了内存管理，减少了手动内存管理可能导致的错误。此外，还会涉及Blocks（代码块）的使用，这是一种内联函数或者闭包的实现，允许在代码中定义可重用的代码片段。关于对象所有权规则，文档可能会讲解Strong和Weak引用的区别，以及如何在ARC环境下正确地管理对象生命周期。此外，KVC（Key-Value Coding）和KVO（Key-Value Observing）机制也是Objective-C中用于数据绑定和动态属性观察的重要特性。文档还可能涵盖多线程编程，Objective-C支持NSOperation和NSOperationQueue来管理并发任务，以及GCD（Grand Central Dispatch）来更高效地利用多核处理器。除此之外，文档会讨论错误处理机制、调试技巧以及如何利用Interface Builder进行可视化设计。《Objective-C 2.0 Programming》是一份全面的学习教程，涵盖了从语言基础到高级特性的各个方面，对于想要学习或提升Objective-C编程技能的开发者来说是一份宝贵的资源。通过深入学习和实践，开发者可以掌握构建高质量iOS和macOS应用所需的技术和知识。

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

afeindsc

粉丝: 1
资源: 10

Objective-C 2.0编程语言详解

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

Objective-C2.0程序设计第二版中文版及代码

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

Objective-C 中文 第二版

Programming in Objective-C 2.0 第二版

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

Objective-c语言学习－快速入门完整版完整版

Objective-C 第二版

objective-c程序设计第二版

Objective-C 基础教程第二版

最新资源

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

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

Objective-C 中文第二版

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