探索Objective-C：面向对象编程与Cocoa深度解析

需积分: 1 139 浏览量更新于2024-07-22 收藏 1.53MB PDF 举报

《Inside Cocoa - 对象导向编程与Objective-C语言详解》是一本深入讲解面向对象编程（OOP）和苹果开发环境及工具的专业书籍，发表于2000年。作者通过对OOP的核心概念如封装、继承和多态进行详尽阐述，使读者对这种编程范式有深刻理解。书中特别强调了Objective-C语言在iOS和macOS平台上的应用，这是Apple Computer, Inc. 推出的专为其软件开发设计的一种编程语言。该书首先介绍了OOP的基本原则，即设计程序时将数据和操作数据的方法结合在一起，形成对象。这有助于创建模块化的代码，提高代码的重用性和可维护性。在Objective-C中，类（Class）是对象的蓝图，它定义了对象的属性（实例变量）和方法（成员函数），这些构成了对象的结构和行为。此外，书中还涵盖了Objective-C语言的关键特性，包括其语法结构，如消息传递（message passing）和动态类型系统，这对于理解和编写高效、灵活的苹果应用程序至关重要。Objective-C允许程序员在运行时添加或修改方法，这一特性在iOS和macOS框架中被广泛应用，如UIKit和Cocoa Frameworks。书中还专门讨论了Apple的开发环境，比如Xcode，它是苹果提供的集成开发环境（IDE），集成了编译器、调试工具和项目管理功能，极大地方便了开发者的工作流程。通过本书，读者能够学习如何利用Xcode的工具来创建、测试和调试Objective-C项目。版权方面，书中的内容受Apple Computer, Inc. 严格保护，未经许可不得复制、存储或传播。任何商业用途的使用都可能涉及商标侵权和不公平竞争，因此在使用苹果技术时必须遵守相应的条款。同时，书中并没有授予任何技术使用的许可，所有的知识产权仍归Apple所有。《Inside Cocoa》是一本为Apple开发者量身打造的指南，深入浅出地揭示了OOP在Objective-C中的实践应用，以及如何有效地在苹果生态系统中进行软件开发。无论是初次接触OOP的新手，还是希望提升Objective-C技能的开发者，这本书都是不可或缺的参考资料。

Interface and Implementation

CHAPTER 2

Object-Oriented Programming

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

fulfill 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. Abstractions reveal

causes and effects, expose patterns and frameworks, and separate what’s important

from what’s not. They’re at the root of understanding.

To invent programs, you need to be able to capture the same kinds of abstractions

and express them in the program design.

It’s the job of a programming language to help you do this. The language should

facilitate the process of invention and design by letting you encode abstractions that

reveal the way things work. It should let you make your ideas concrete in the code

you write. Surface details shouldn’t obscure the architecture of your program.

All programming languages provide devices that help express abstractions. In

essence, these devices are ways of grouping implementation details, hiding them,

and giving them, at least to some extent, a common interface—much as a

mechanical object separates its interface from its implementation.

Interface and Implementation

CHAPTER 2

Object-Oriented Programming

■

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 fields 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 defined, 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 significant 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

reflect, at the highest level, the way the computer works.

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

and functions—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.

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 first step toward creating an

object.

CHAPTER 2

Object-Oriented Programming

Interface and Implementation

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 access to 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 first create the object (thus giving it its internal data structure), then tell

the object which function it should perform. 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 learning object-oriented programming. It

may seem unfamiliar at first, but as you gain experience with object-oriented

programming, you’ll find 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 difficult as programs become bigger

and more complicated.

By providing another, higher level of abstraction, object-oriented programming

languages give you a larger vocabulary and a richer model to program in.

剩余193页未读，继续阅读

ggwang09

粉丝: 0
资源: 12

探索Objective-C：面向对象编程与Cocoa深度解析

Object-Oriented Programming with Objective-C

Object-Oriented Programming with Object-C

Objective-C: From Zero to Hero - Object Oriented Programming 1

Objective-C: From Zero to Hero - Object Oriented Programming 2

Using-Swift-with-Cocoa-and-Objective-C(4.1)

Cocoa-Objective-C----Drag-and-Drop:此源代码显示了如何在Xcode 4.2 [Cocoa Mac App]中使用拖放操作。-Show source code

-the-swift-programming-language-中文版

Cocoa and Objective-C programming

The Objective-C Programming Language-2006.pdf

MySQL Objective C API for Cocoa-开源

最新资源