Objective-C 2.0编程语言：iPhone应用开发基础

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

"Objective-C 第二版 - 开发iPhone应用必学语言" Objective-C，作为苹果公司开发iPhone应用的核心编程语言，是iOS、macOS以及WatchOS等平台软件开发的重要工具。Objective-C 第二版主要针对Cocoa框架进行编程，它是苹果的高级应用程序接口（API）集合，用于构建强大的桌面和移动应用程序。 Objective-C是一种基于C语言的面向对象编程语言，它扩展了C语言，引入了Smalltalk风格的消息传递机制。在Objective-C 2.0中，该语言进行了若干关键的更新和改进，使得代码更简洁，开发过程更高效。 1. **消息传递**：Objective-C的核心概念是消息传递。当对象发送一个消息给另一个对象时，实际上是调用方法。这种设计允许动态绑定，即在运行时决定调用哪个方法，增强了代码的灵活性。 2. **类别（Category）**：Objective-C支持类别，允许开发者扩展已有的类，添加新的方法，而无需继承。这在不改变原有类结构的情况下，增强了代码的可复用性和模块化。 3. **协议（Protocol）**：类似于Java和C#的接口，Objective-C的协议定义了一组方法签名，可以被多个类实现。协议常用于定义代理（delegate）模式，实现对象间的通信。 4. **块（Block）**：Objective-C 2.0引入了块（Block），这是一种内联函数，可以捕获并存储其作用域内的变量。块在异步编程、事件处理和算法中非常有用。 5. **自动引用计数（ARC）**：Objective-C 2.0引入了自动引用计数，减轻了手动管理内存的工作，减少了内存泄漏的风险。ARC自动跟踪并管理对象的生命周期，当不再有引用指向对象时，会自动释放它。 6. **垃圾回收（Garbage Collection）**：虽然ARC成为主流，但Objective-C 2.0仍支持垃圾回收，特别是在某些特定情况下，如服务器端或跨平台开发。 7. **Key-Value Coding (KVC) 和 Key-Value Observing (KVO)**：KVC是一种间接访问对象属性的方式，允许通过键值字符串来操作属性。KVO则允许对象监听其他对象的属性变化，从而实现数据绑定。 8. **Foundation 和 Cocoa Frameworks**：Objective-C的开发通常基于Foundation和Cocoa框架，提供基础数据类型、线程管理、网络编程等服务。Cocoa则提供了丰富的UI组件和系统服务，使得开发者能构建功能丰富的用户界面。 9. **Objective-C runtime**：Objective-C的运行时库提供了许多底层功能，比如动态类型和消息转发，这使得Objective-C具备高度的灵活性和动态性。 10. **Interface Builder**：苹果提供的图形化界面构建工具，与Objective-C紧密集成，允许开发者拖放UI元素，快速创建和布局用户界面。学习Objective-C 2.0不仅意味着掌握一种编程语言，更意味着熟悉苹果的开发环境和生态系统，包括Xcode集成开发环境、Cocoa Touch框架等。对于想要开发苹果平台应用的开发者来说，深入理解这些知识点至关重要。

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

电脑无人

粉丝: 0
资源: 2

Objective-C 2.0编程语言：iPhone应用开发基础

Objective-C 2.0编程语言中文版：全面指南

Objective-C 2.0编程语言详解

Objective-C 2.0编程语言指南

Cocoa入门 使用Objective-C 第二版70m

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

Objective-C 中文 第二版

Programming in Objective-C 2.0 第二版

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

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

Objective-C基础教程第二版

最新资源

Cocoa入门使用Objective-C 第二版70m

Objective-C 中文第二版

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

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