Objective-C编程语言详解

需积分: 3 172 浏览量更新于2024-07-28 收藏 1.15MB PDF 举报

"Objective-C是苹果公司开发的一种面向对象的编程语言，主要应用于iPhone和iOS平台的软件开发。本文档由Apple Inc.于2010年发布，详细介绍了Objective-C编程语言，包括其工具和语言特性。文档指出，任何复制、存储、传输此文档内容的行为都需要获得Apple Inc.的书面许可，除非是为了个人使用目的。同时，文档警告未经许可使用Apple商标可能会触犯商标侵权和不公平竞争的法律。文档的目的在于帮助应用开发者理解和使用Objective-C进行软件开发，但不提供任何技术的明示或暗示许可证，所有与技术相关的知识产权归Apple Inc.所有。" Objective-C作为苹果生态系统的核心编程语言，它的主要特点和知识点包括： 1. **面向对象**：Objective-C是C语言的扩展，增加了Smalltalk风格的消息传递机制，使得它具备面向对象的能力。类、对象、继承、多态、封装等面向对象的基本概念在Objective-C中都有实现。 2. **动态性**：Objective-C具有很强的动态性，允许在运行时决定消息发送给哪个对象，以及决定对象响应哪些消息。这种动态性来源于它的消息机制和运行时系统。 3. **Category**：Objective-C的类别（Category）特性允许开发者为已有的类添加方法，而无需子类化。这对于扩展系统的类或者第三方库的功能非常有用。 4. **Block（块）**：Objective-C支持Block，这是一种内联函数或者闭包的表示方式，可以作为参数传递，也可以作为返回值，常用于异步编程和回调。 5. **Foundation框架和AppKit/UIKit框架**：Objective-C的开发通常会用到Foundation框架，它是Cocoa和Cocoa Touch的基础，提供了各种基础数据类型、集合类和I/O操作。AppKit用于Mac OS X开发，UIKit用于iOS开发，这两个框架包含了大量的UI控件和事件处理机制。 6. **Memory Management（内存管理）**：Objective-C在早期版本中使用了手动的内存管理，包括引用计数（Reference Counting）和autorelease池。后来引入的ARC（Automatic Reference Counting）自动管理内存，极大地简化了内存管理的工作。 7. **Interface Builder**：Xcode中的Interface Builder是设计用户界面的工具，通过拖放的方式创建和布局UI元素，与Objective-C代码紧密结合，实现了设计和逻辑的分离。 8. **NSObjCRuntime**：Objective-C的运行时库（NSObjCRuntime）是实现Objective-C特性的关键，它包含了类的元数据、方法解析、消息转发等功能。 9. **GCD（Grand Central Dispatch）**：苹果提供的多线程和并发解决方案，GCD可以帮助开发者有效地利用多核处理器，提高应用程序的性能。 10. **NSNotifications** 和 **KVO（Key-Value Observing）**：这两种机制用于对象间的通信和状态观察，提供了松耦合的事件通知方式。 Objective-C是iOS和Mac开发的重要工具，虽然现在Swift已经逐渐成为首选语言，但Objective-C的知识仍然对理解苹果平台的开发至关重要。掌握Objective-C的这些核心概念和特性，有助于开发者更好地进行iOS和Mac应用的开发。

For methods with multiple arguments, Objective-C's method names are interleaved with the arguments such

that the method’s name naturally describes the arguments expected by the method. The imaginary message

below tells the myRectangle object to set its origin to the coordinates (30.0, 50.0):

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

arguments

A selector name includes all the parts of the name, including the colons, so the method is named

setOriginX:y:. It has two colons as it takes two arguments. The selector name does not, however, include

anything else, such as return type or parameter types.

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 (see Messaging in the Objective-C 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.

In principle, the Rectangle class could instead implement a setOrigin:: which would be invoked as follows:

[myRectangle setOrigin:30.0 :50.0]; // This is a bad example of multiple 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.

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:

[myRectangle setPrimaryColor:[otherRect primaryColor]];

Objective-C 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

“Declared Properties” (page 67)), and is described in “Dot Syntax” (page 19).

Object Messaging

CHAPTER 1

Objects, Classes, and Messaging

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, then a message sent to nil returns 0 (nil), for example:

Person *motherInLaw = [[aPerson spouse] mother];

If aPerson’s spouse is nil, then mother is sent to nil and the method returns nil.

■ If the method returns 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 slightly with Mac OS X v10.5.

On Mac OS X v10.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.

Object Messaging 17

CHAPTER 1

Objects, Classes, and Messaging

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.

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

Object Messaging

CHAPTER 1

Objects, Classes, and Messaging

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

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];

Object Messaging 19

CHAPTER 1

Objects, Classes, and Messaging

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

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

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

19), 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];

if ([graphic isTextHidden] != YES) {

[graphic setText:@"Hello"];

}

[graphic setBounds:NSMakeRect(10.0, 10.0, 20.0, 120.0)];

An advantage of the dot syntax is that the compiler can signal an error when it detects a write to a read-only

property, whereas at best it can only generate an undeclared method warning that you invoked a non-existent

setProperty: method, which will fail at runtime.

For properties of the appropriate C language type, the meaning of compound assignments is well-defined.

For example, you could update the length property of an instance of NSMutableData using compound

assignments:

NSMutableData *data = [NSMutableData dataWithLength:1024];

data.length += 1024;

data.length *= 2;

data.length /= 4;

which is equivalent to:

[data setLength:[data length] + 1024];

[data setLength:[data length] * 2];

[data setLength:[data length] / 4];

There is one case where properties cannot be used. Consider the following code fragment:

id y;

Object Messaging

CHAPTER 1

Objects, Classes, and Messaging

剩余136页未读，继续阅读

ken_henderson

粉丝: 2
资源: 11

Objective-C编程语言详解

Objective C 串口通信源码

从C++到Objective C的学习之路

ObjectiveC 学习 入门基 础教程第2版

Objective C 冒泡算法实例

objective c编程全解 pdf

objectivec基础教程 第2版 pdf

objectivec文档

(2)若有列表list1-['Windows,'MacOS,'Linux',"HarmonyOS'list2-['C++','ObjectiveC,C,'C]，请编程实现输出以下效果：.(Windows':'C++','MacOS':'Objective-C','Linux':'C',"HarmonyOS':C)。(20分)

iOS 获取当前时间毫秒值 Objective c

(2)若有列表list1 = [Windows', 'Macos, 'Linux', 'HarmonyOs',list2=['C++', 'Objective-C', 'C, 'C]，请编程实现输出以下效果:。{"Windows': 'C++, "MacOS': 'Objective C', 'Linux': 'C, 'HarmonyOS':'C')。 (20分) .

最新资源

ObjectiveC 学习入门基础教程第2版

objectivec基础教程第2版 pdf