Objective-C 2.0编程语言详解

需积分: 10 49 浏览量更新于2024-07-29 收藏 1.12MB PDF 举报

“The Objective-C 2.0 Programming Language” 是一份关于Objective-C编程语言的PDF教程，由Apple Inc.在2008年发布。这份文档涵盖了Objective-C 2.0的主要特性和使用方法，是学习和理解Objective-C语言的重要参考资料。 Objective-C是一种面向对象的编程语言，它是C语言的超集，主要被用于苹果的操作系统，如macOS和iOS的软件开发，特别是在Cocoa框架下。Objective-C 2.0是该语言的一个版本，引入了一些改进和新特性，提高了开发效率和代码的可读性。本教程可能包括以下内容： 1. 基础语法：Objective-C的基础语法与C语言相似，但增加了消息传递机制，这是Objective-C的核心特性。通过发送消息给对象来调用其方法，如`[receiver message]`。 2. 类和对象：Objective-C中的所有事物都是对象，由类定义。类是对象的蓝图，包含了数据（属性）和行为（方法）的定义。Objective-C支持类继承，可以创建子类以扩展或修改父类的功能。 3. 协议（Protocols）：Objective-C的协议类似于Java或C#的接口，定义了一组方法签名，可以被类实现或者作为类别（Category）的一部分来遵循。 4. 类别（Category）：Objective-C允许为已存在的类添加方法，而无需创建子类，这就是类别。类别常用于扩展框架中的类。 5. 块（Blocks）：Objective-C 2.0引入了块（Blocks），这是一种内联函数或闭包的语法，可以在代码中捕获和存储执行上下文，增强了函数式编程的能力。 6. 内存管理：Objective-C使用引用计数进行内存管理，早期版本依赖于手动的`retain`和`release`，而Objective-C 2.0引入了ARC（Automatic Reference Counting），自动处理大部分内存管理任务。 7. 属性（Properties）：Objective-C 2.0引入了属性，提供了一种更安全、更简洁的方式来访问和设置实例变量，支持自动合成、内存管理策略等。 8. 垃圾回收（Garbage Collection）：虽然Objective-C 2.0支持垃圾回收，但在现代iOS和macOS开发中，通常使用ARC替代，因为GC在某些场景下可能导致性能问题。 9. Foundation框架：Objective-C的很多基本功能和数据类型都包含在Foundation框架中，如字符串（NSString）、数组（NSArray）、字典（NSDictionary）等。 10. Cocoa和Cocoa Touch：Apple的开发框架，Cocoa是针对macOS的，Cocoa Touch则是针对iOS的，它们为开发者提供了构建应用程序所需的各种服务和组件。本教程可能详细讲解了这些概念，并通过示例代码来演示如何在实践中应用Objective-C 2.0的特性。对于想要学习Objective-C或已经在使用Objective-C进行开发的程序员来说，这是一个非常有价值的资源。

Methods can also take parameters, or “arguments.” A message with a single argument affixes a colon (:) to

the selector name and puts the argument right after the colon. This construct is called a keyword; a keyword

ends with a colon, and an argument follows the colon, as shown in this example:

[myRectangle setWidth:20.0];

A selector name includes all keywords, including colons, but does not include anything else, such as return

type or parameter types. The imaginary message below tells the myRectangle object to set its origin to the

coordinates (30.0, 50.0):

[myRectangle setOrigin:30.0 :50.0]; // This is a bad example of multiple arguments

Since the colons are part of the method name, the method is named setOrigin::. It has two colons as it

takes two arguments. This particular method does not interleave the method name with the arguments and,

thus, the second argument is effectively unlabeled and it is difficult to determine the kind or purpose of the

method’s arguments.

Instead, method names should interleave the name with the arguments such that the method's name naturally

describes the arguments expected by the method. For example, the Rectangle class could instead implement

a setOriginX:y: method that makes the purpose of its two arguments clear:

[myRectangle setOriginX: 30.0 y: 50.0]; // This is a good example of multiple

arguments

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 (seeMessaging in the Objective-C 2.0 Runtime Programming Guide). 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 myRectangle is drawn as a solid rectangle, or NO if it’s drawn in outline form only.

BOOL isFilled;

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

Object Messaging

CHAPTER 1

Objects, Classes, and Messaging

Note: The behavior of sending messages to nil changed slightly with Mac OS X v10.5.

On MacOSXv10.4 and earlier, a message to nil also is valid, as long as the message returns an object, any

pointer type, void, or any integer scalar of size less than or equal to sizeof(void*); if it does, a message

sent to nil returns nil. If the message sent to nil returns anything other than the aforementioned value

types (for example, if it returns any struct type, any floating-point type, or any vector type) the return value

is undefined. You should therefore not rely on the return value of messages sent to nil unless the method’s

return type is an object, any pointer type, or any integer scalar of size less than or equal to sizeof(void*).

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

CHAPTER 1

Objects, Classes, and Messaging

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 Messaging in the Objective-C 2.0 Runtime Programming Guide.)

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 Messaging in the

Objective-C 2.0 Runtime Programming Guide.

Dynamic Method Resolution

You can provide implementations of class and instance methods at runtime using dynamic method resolution.

See Dynamic Method Resolution in the Objective-C 2.0 Runtime Programming Guide for more details.

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 19

CHAPTER 1

Objects, Classes, and Messaging

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 = 10;

printf("myInstance value: %d", 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:10];

printf("myInstance value: %d", [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);

(@"Hello" is a constant NSString object—see “Compiler Directives” (page 114).)

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

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 Listing 1-1 (page

20), but use square bracket syntax:

Listing 1-2 Accessing properties using bracket syntax

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

NSColor *color = [graphic color];

CGFloat xLoc = [graphic xLoc];

BOOL hidden = [graphic hidden];

int textCharacterLength = [[graphic text] length];

Object Messaging

CHAPTER 1

Objects, Classes, and Messaging

剩余132页未读，继续阅读

Sodaslay

粉丝: 127
资源: 12

Objective-C 2.0编程语言详解

Objective-C 2.0编程语言（Apple Inc.）The Objective-C 2.0 Programming Language (Apple Inc.)

Objective-C 2.0 Programming Language

Objective-C - Learning Objective-C 2.0 Second Edition

Programming in Objective-C 2.0

Objective-C 2.0编程指南

Objective-C 2.0编程语言详解

Objective-C 2.0编程语言指南

Java基于springboot+vue的校园自助洗衣服务管理系统的设计与实现.rar

广义表的基本操作与高级功能

舷侧和端射天线阵列辐射方向图 matlab代码.rar

最新资源