苹果官方Objective-C编程语言入门指南

需积分: 9 55 浏览量更新于2024-07-31 收藏 911KB PDF 举报

"Object-c 入门教程 - 最官方，最权威的objcet-c教程，适用于Iphone、COCOA开发" Objective-C是一种面向对象的编程语言，它是Apple Inc.在其操作系统，包括iOS和macOS上进行软件开发的主要编程语言。Objective-C是C语言的一个扩展，添加了Smalltalk风格的消息传递机制和类的概念，使其成为开发Apple平台应用程序的强大工具。本教程可能涵盖以下主要知识点： 1. **Objective-C基础**： - **语法**：Objective-C的语法与C语言类似，但也有一些独特之处，如类定义、方法声明和消息传递。 - **对象模型**：了解如何定义类，创建实例，以及继承和多态性的概念。 - **内存管理**：Objective-C使用引用计数来管理内存，理解`retain`、`release`、`autorelease`等关键字的用法。 - **属性（Properties）**：Objective-C引入了属性，简化了对实例变量的访问和管理。 2. **消息传递**： - **方法调用**：Objective-C中的方法调用称为消息传递，它使用方括号语法 `[receiver message]`。 - **动态类型**：Objective-C允许在运行时确定对象类型，这是消息传递的一个关键特性。 3. **Cocoa框架**： - **Foundation框架**：提供基本的数据类型、集合类和系统服务，是所有Objective-C程序的基础。 - **AppKit/UIKit**：分别用于macOS和iOS应用开发，提供了用户界面元素和事件处理。 4. ** Blocks**： - Objective-C支持Block（代码块），这是一种可以作为值传递的匿名函数，常用于异步操作和简化回调。 5. **GCD (Grand Central Dispatch)**： - Apple的并行和并发处理技术，用于高效利用多核处理器。 6. **ARC (Automatic Reference Counting)**： - 自动引用计数是Objective-C的内存管理机制，它自动处理对象的生命周期，减少了手动内存管理的工作。 7. **Instruments工具**： - Xcode集成的性能分析工具，用于调试和优化代码。 8. **Interface Builder**： - 一个可视化的UI设计工具，可以与Xcode集成，帮助开发者快速构建用户界面。 9. **iBook/iBooks Author**： - 可能涉及到使用Objective-C编写iBooks应用或创建电子书内容。 10. **iOS/macOS应用开发流程**： - 从项目创建到发布，包括 storyboard 编辑、模拟器测试、真机调试、App Store提交等步骤。本教程适合初学者，旨在通过详尽的讲解和实例，引导学习者掌握Objective-C编程，并能够运用到实际的iPhone、iPad及Mac应用开发中。由于Objective-C是Apple生态系统的核心语言之一，学习它将为开发Apple平台的应用打下坚实的基础。

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

such that the method’s name naturally describes the parameters 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 parameters

A selector name includes all the parts of the name, including the colons, so the selector in the preceding

example is named setOriginX:y:. It has two colons, because it takes two parameters. The selector name

does not, however, include anything else, such as return type or parameter types.

Important: The subparts of an Objective-C selector name are not optional, nor can their order be varied. In

some languages, the terms “named parameters” and “keyword parameters” carry the implications that the

parameters can vary at runtime, can have default values, can be in a different order, and can possibly have

additional named parameters. None of these characteristics about parameters are true for Objective-C.

For all intents and purposes, an Objective-C method declaration is simply a C function that prepends two

additional parameters (see “Messaging” in the Objective-C Runtime Programming Guide). Thus, the structure

of an Objective-C method declaration differs from the structure of a method that uses named or keyword

parameters in a language like Python, as the following Python example illustrates:

def func(a, b, NeatMode=SuperNeat, Thing=DefaultThing):

pass

In this Python example, Thing and NeatMode might be omitted or might have different values when called.

In principle, a Rectangle class could instead implement a setOrigin:: method with no label for the

second parameter, which would be invoked as follows:

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

parameters

While syntactically legal, setOrigin:: does not interleave the method name with the parameters. Thus,

the second parameter is effectively unlabeled and it is difficult for a reader of this code to determine the kind

or purpose of the method’s parameters.

Methods that take a variable number of parameters are also possible, though they’re somewhat rare. Extra

parameters are separated by commas after the end of the method name. (Unlike colons, the commas are

not considered part of the name.) In the following example, the imaginary makeGroup: method is passed

one required parameter (group) and three parameters 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]];

Object Messaging

CHAPTER 1

Objects, Classes, and Messaging

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

In 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. Therefore, in Mac OS X v10.4 and earlier, you should 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 parameters. For example, the primaryColor method illustrated above takes no parameters,

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

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 parameters 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 earlier are used for just this purpose.

See “Defining a Class” (page 35) for more information on referring to instance variables.

Polymorphism

As the earlier examples 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 don’t behave in the same way

that function calls do.

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. Therefore, two objects can respond differently to the same message. For example, each kind of object

that receives 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 parameters 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 invoked to respond to a message can be

determined only at runtime, not when the code is compiled.

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 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. Because each object can have its own version of a method,

an Objective-C statement can achieve a variety of results, not by varying the message but by varying the

object that receives the message. Receivers can be decided as the program runs; the choice of receiver can

be made dependent on factors such as user actions.

When executing code based upon the Application Kit (AppKit), for example, users determine which objects

receive messages from menu commands such as 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

to a copy message than a Rectangle would. Because messages do not select methods until runtime (from

another perspective, because binding of methods to messages does not occur until runtime), these differences

in behavior are isolated to the methods themselves. The code that sends the message doesn’t have to be

concerned with them; it doesn’t even have to enumerate the possibilities. An application’s objects can each

respond in its 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 determined at runtime. This mechanism is discussed in the section “Messaging” in

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 Objective-C Runtime Programming Guide for more details.

Dot Syntax

Objective-C provides a dot (.) operator that offers an alternative to square bracket notation ([]) to invoke

accessor methods. Dot syntax uses the same pattern that accessing C structure elements uses:

myInstance.value = 10;

printf("myInstance value: %d", myInstance.value);

When used with objects, however, dot syntax acts as “syntactic sugar”—it is transformed by the compiler

into an invocation of an accessor method. Dot syntax does not directly get or set an instance variable. The

code example above is exactly equivalent to the following:

[myInstance setValue:10];

printf("myInstance value: %d", [myInstance value]);

Object Messaging 19

CHAPTER 1

Objects, Classes, and Messaging

As a corollary, if you want to access an object’s own instance variable using accessor methods, you must

explicitly call out self, for example:

self.age = 10;

or the equivalent:

[self setAge:10];

If you do not use self., you access the instance variable directly. In the following example, the set accessor

method for age is not invoked:

age = 10;

An advantage of dot syntax is that its representation is more compact and may be more readable than the

corresponding square bracket notation, particularly 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). A further advantage is that the

compiler can signal an error when it detects an attempt to write to a read-only declared property. If you

instead use square bracket syntax for accessing variables, the compiler—at best—generates only an undeclared

method warning that you invoked a nonexistent setter method, and the code fails at runtime.

General Use

When you use dot syntax to get a value, the system calls the associated getter accessor method. By default,

the getter method has the same name as the symbol following the dot. Using dot syntax to set a value calls

the associated setter accessor method. By default, the setter method is named by capitalizing the symbol

following the dot and prefixing it with “set.” If you don’t want to use default accessor names, you can change

them by using the declared properties feature (see “Declared Properties” (page 69)).

Listing 1-1 illustrates several use cases.

Listing 1-1 Accessing properties using 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"; // @"Hello" is a constant NSString object.

}

graphic.bounds = NSMakeRect(10.0, 10.0, 20.0, 120.0);

The statements in Listing 1-2 compile to exactly the same code as the statements using dot syntax shown

in Listing 1-1 (page 20), but instead 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

剩余115页未读，继续阅读

koko516

粉丝: 1
资源: 14

苹果官方Objective-C编程语言入门指南

Windows下安装开发Object-C

OBject-c源码

Object-C中文版

学习 Object-C入门教程

Object-c入门教程中文版【电子书+源码】

Object-C 入门教程：从零开始学习

Object-C入门教程：Cocoa框架与GNUStep实践

Object-C入门教程：环境配置与基础概念

Object-C入门教程：从零开始学习iOS开发

Object-C语言入门与实践教程.zip

最新资源