Objective-C语言基础教程速览

需积分: 0 55 浏览量更新于2024-06-26 收藏 1.14MB PDF 举报

"这篇文档是关于Objective-C编程语言的基础概要，主要涵盖了面向对象编程和Objective-C语言的关键点。" Objective-C是Apple开发的一种强大的面向对象编程语言，它基于C语言，并添加了Smalltalk的面向对象特性。在Objective-C中，主要的编程概念包括类、对象、消息传递和协议。 1. **类与对象**: 类是Objective-C中的基本构建块，它是创建对象的蓝图。对象则是类的实例，它们具有特定的属性（称为实例变量）和行为（方法）。你可以通过定义类来描述一个对象的结构和功能，然后创建多个该类的对象。 2. **消息传递**: Objective-C中的对象通过发送消息来交互。当你调用一个对象的方法时，实际上是在向该对象发送一条消息。消息传递机制是Objective-C的核心，它允许动态绑定，即在运行时确定哪个方法将处理特定的消息。 3. **关键字`: `**在Objective-C中，`:`是一个特殊字符，用于在消息中传递参数。例如，`[myObject doSomething:anArgument]`，这里的`:anArgument`就是参数的传递。 4. **动态类型**: Objective-C是一种动态类型的语言，这意味着在编译时不需要显式声明变量的类型。对象可以被视为其基类的类型，这使得多态性成为可能。 5. **协议**: Objective-C的协议类似于Java和C#的接口，定义了一组必须被实现的方法。一个类可以遵循多个协议，从而扩展其功能而不必继承其他类。 6. **Category**: Category是Objective-C的一个特性，允许向已存在的类添加方法，而无需继承。这在不修改原有代码的情况下扩展类的功能非常有用。 7. **Blocks**: Blocks是Objective-C 2.0引入的特性，它允许在代码中定义匿名函数，类似于其他语言的lambda表达式或闭包。Blocks可以作为参数传递，也可以存储在变量中。 8. **Memory Management**: Objective-C使用引用计数（Reference Counting）进行内存管理，每个对象都有一个引用计数器，当对象的引用计数变为零时，对象会被自动释放。从iOS 5开始，苹果引入了ARC（Automatic Reference Counting），进一步简化了内存管理。 9. **Foundation框架**: Foundation框架是Objective-C开发的基础，它提供了一系列核心的类和工具，如NSArray、NSDictionary、NSString等，以及线程、文件系统和网络操作的支持。 10. **Cocoa Touch**: 对于iOS开发，Objective-C结合Cocoa Touch框架，提供了创建用户界面和处理用户交互所需的所有工具和类。尽管现代的Swift语言已经逐渐取代Objective-C成为Apple平台的主要开发语言，但Objective-C仍然是许多现有项目和库的基础，对于理解iOS和macOS的底层工作原理仍然非常重要。

Programming languages have traditionally divided the world into two parts—

data and operations on data. Data is static and immutable, except as the

operations may change it. The procedures and functions that operate on data

have no lasting state of their own; they’re useful only in their ability to affect

data.

This division is, of course, grounded in the way computers work, so it’s not one

that you can easily ignore or push aside. Like the equally pervasive distinctions

between matter and energy and between nouns and verbs, it forms the

background against which we work. At some point, all programmers—even

object-oriented programmers—must lay out the data structures that their

programs will use and deﬁne the functions that will act on the data.

With a procedural programming language like C, that’s about all there is to it.

The language may offer various kinds of support for organizing data and

functions, but it won’t divide the world any differently. Functions and data

structures are the basic elements of design.

Object-oriented programming doesn’t so much dispute this view of the world as

restructure it at a higher level. It groups operations and data into modular units

called objects and lets you combine objects into structured networks to form a

complete program. In an object-oriented programming language, objects and

object interactions are the basic elements of design.

Every object has both state (data) and behavior (operations on data). In that,

they’re not much different from ordinary physical objects. It’s easy to see how a

mechanical device, such as a pocket watch or a piano, embodies both state and

behavior. But almost anything that’s designed to do a job does too. Even simple

things with no moving parts such as an ordinary bottle combine state (how full

the bottle is, whether or not it’s open, how warm its contents are) with behavior

(the ability to dispense its contents at various ﬂow rates, to be opened or closed,

to withstand high or low temperatures).

It’s this resemblance to real things that gives objects much of their power and

appeal. They can not only model components of real systems, but equally as

well fulﬁll assigned roles as components in software systems.

Interface and Implementation

As humans, we’re constantly faced with myriad facts and impressions that we

must make sense of. To do so, we have to abstract underlying structure away

from surface details and discover the fundamental relations at work.

others, so a complex arrangement of information can be built from simpler

layers.

In modern C, the ﬁelds of a structure live in their own name space—that is,

their names won’t conﬂict with identically-named data elements outside the

structure. Partitioning the program name space is essential for keeping

implementation details out of the interface. Imagine, for example, the

enormous task of assigning a different name to every piece of data in a large

program and of making sure new names don’t conﬂict with old ones.

On the procedural side of the world, functions encapsulate behaviors that can

be used repeatedly without being reimplemented. Data elements local to a

function, like the ﬁelds within a structure, are protected within their own

name space. Functions can reference (call) other functions, so quite complex

behaviors can be built from smaller pieces.

Functions are reusable. Once deﬁned, they can be called any number of

times without again considering the implementation. The most generally

useful functions can be collected in libraries and reused in many different

applications. All the user needs is the function interface, not the source code.

However, unlike data elements, functions aren’t partitioned into separate

name spaces. Each function must have a unique name. Although the

function may be reusable, its name is not.

C structures and functions are able to express signiﬁcant abstractions, but they

maintain the distinction between data and operations on data. In a procedural

programming language, the highest units of abstraction still live on one side or

the other of the data-versus-operations divide. The programs you design must

always reﬂect, at the highest level, the way the computer works.

Object-oriented programming languages don’t lose any of the virtues of

structures and functions. But they go a step further and add a unit capable of

abstraction at a higher level, a unit that hides the interaction between a function

and its data.

Suppose, for example, that you have a group of functions that all act on a

particular data structure. You want to make those functions easier to use by, as

far as possible, taking the structure out of the interface. So you supply a few

additional functions to manage the data. All the work of manipulating the data

structure—allocating it, initializing it, getting information from it, modifying

values within it, keeping it up to date, and freeing it—is done through the

functions. All the user does is call the functions and pass the structure to them.

■

Chapter 1 Object-Oriented Programming

With these changes, the structure has become an opaque token that other

programmers never need to look inside. They can concentrate on what the

functions do, not how the data is organized. You’ve taken the ﬁrst step toward

creating an object.

The next step is to give this idea support in the programming language and

completely hide the data structure so that it doesn’t even have to be passed

between the functions. The data becomes an internal implementation detail; all

that’s exported to users is a functional interface. Because objects completely

encapsulate their data (hide it), users can think of them solely in terms of their

behavior.

With this step, the interface to the functions has become much simpler. Callers

don’t need to know how they’re implemented (what data they use). It’s fair now

to call this an “object.”

The hidden data structure unites all of the functions that share it. So an object

is more than a collection of random functions; it’s a bundle of related behaviors

that are supported by shared data. To use a function that belongs to an object,

you ﬁrst create the object (thus giving it its internal data structure), then tell the

object which function it should invoke. You begin to think in terms of what the

object does, rather than in terms of the individual functions.

This progression from thinking about functions and data structures to thinking

about object behaviors is the essence of object-oriented programming. It may

seem unfamiliar at ﬁrst, but as you gain experience with object-oriented

programming, you’ll ﬁnd it’s a more natural way to think about things. Everyday

programming terminology is replete with analogies to real-world objects of

various kinds—lists, containers, tables, controllers, even managers.

Implementing such things as programming objects merely extends the analogy

in a natural way.

A programming language can be judged by the kinds of abstractions that it

enables you to encode. You shouldn’t be distracted by extraneous matters or

forced to express yourself using a vocabulary that doesn’t match the reality

you’re trying to capture.

If, for example, you must always tend to the business of keeping the right data

matched with the right procedure, you’re forced at all times to be aware of the

entire program at a low level of implementation. While you might still invent

programs at a high level of abstraction, the path from imagination to

implementation can become quite tenuous—and more and more difﬁcult as

programs become bigger and more complicated.

剩余177页未读，继续阅读

etcix

粉丝: 144

Objective-C语言基础教程速览

Objective-C语法快速参考

primus-emitter-objc:primus-objc 的简单发射器包装器

NBJNibBasedView-ObjC:基于简易笔尖的自定义视图

DGDownloadManager:适用于iOS ObjC的简单下载管理器

objc4

objc代码-first objc demo

Prism-objc:使用 JavaScriptCore 的 Objective-C Wrapper for Prism（JavaScript 语法高亮器）

connectedadsdk_objc

objc.dll

ObjC前期总结

最新资源