Cocoa编程基础指南：探索Cocoa框架

需积分: 0 75 浏览量更新于2024-07-31 收藏 8.23MB PDF 举报

"CocoaFundamentals.pdf - 一本关于Cocoa框架基础的指南，涵盖了Cocoa的核心概念、对象、行为添加以及设计模式。" 在Mac OS X开发领域，Cocoa框架是构建原生应用程序的基础，它提供了丰富的工具和类库，帮助开发者创建出功能强大且用户界面友好的应用。《Cocoa Fundamentals Guide》这本书详细介绍了Cocoa的各个方面，旨在帮助开发者更好地理解和使用这一框架。首先，第一章"什么是Cocoa?"会介绍Cocoa的基本概念，包括其历史、组成和在OS X系统中的作用。Cocoa由Foundation框架和AppKit框架组成，这两个框架提供了创建应用程序所需的基本服务和UI组件。Cocoa基于Objective-C编程语言，并引入了诸如消息传递、协议、类别等面向对象的特性。第二章"Cocoa对象"深入讨论了Cocoa中的对象模型，包括Objective-C的内存管理策略（如引用计数）以及如何使用NSObjects、NSControllers和NSDelegates等核心类。此外，还会讲解对象的生命周期、分类和继承，以及如何使用协议来实现多态性。第三章"向Cocoa程序添加行为"则关注如何将逻辑代码与界面元素结合，实现事件处理和用户交互。这包括了解事件驱动的编程模型，使用NSResponder链来响应用户操作，以及如何使用IBActions和IBOutlets连接界面与代码。第四章"Cocoa设计模式"探讨了Cocoa中常见的设计模式，如Model-View-Controller (MVC)架构、Singletons、Observer模式等。这些模式有助于编写可维护、可扩展的代码，同时保持良好的软件设计原则。附录A "Mac OS X的核心应用架构"详细解析了OS X下的应用程序结构，包括应用程序生命周期、主运行循环以及如何与操作系统进行交互。而附录B则涉及了其他在OS X上的Cocoa架构，可能涵盖不同类型的Cocoa应用，如基于WebKit的应用或Cocoa Touch在iOS上的应用。这本书对于希望深入学习Cocoa和OS X开发的程序员来说是一份宝贵的资源，它不仅涵盖了Cocoa的基本要素，还提供了实践经验，帮助开发者掌握构建高质量Mac应用的技能。通过学习这本书，开发者能够理解并熟练运用Cocoa的各个层面，从而创作出符合苹果平台标准的优秀应用。

iOS Note: Cocoa for iOS supports only application development and not development of any other kind of

executable.

You may use several programming languages when developing Cocoa software, but the essential, required

language is Objective-C. Objective-C is a superset of ANSI C that has been extended with certain syntactical

and semantic features (derived from Smalltalk) to support object-oriented programming. The few added

conventions are simple and easy to learn and use. Because Objective-C rests on a foundation of ANSI C, you

can freely intermix straight C code with Objective-C code. Moreover, your code can call functions defined in

non-Cocoa programmatic interfaces, such as the BSD library interfaces in /usr/include. You can even mix

C++ code with your Cocoa code and link them into the same executable.

Mac OS X Note: On Mac OS X, you can also program in Cocoa using scripting bridges such as PyObjC (the

Python–Objective-C bridge) and RubyCocoa (the Ruby–Cocoa bridge). Both bridged languages let you write

Cocoa applications in the respective scripting languages, Python and Ruby. Both of these are interpreted,

interactive, and object-oriented programming languages that make it possible for Python or Ruby objects

to message Objective-C objects as if they're Python or Ruby objects, and also for Objective-C objects to

message Python or Ruby objects. For more information, see Ruby and Python Programming Topics for Mac OS

The most important Cocoa class libraries come packaged in two core frameworks for each platform: Foundation

and Application Kit for Mac OS X and Foundation and UIKit for iOS. As with all frameworks, these contain not

only a dynamically sharable library (or sometimes several compatibility versions of libraries), but header files,

API documentation, and related resources. The duo of both Application Kit and Foundation and UIKit and

Foundation reflect the division of the Cocoa programmatic interfaces into those classes that have some

bearing on a graphical user interface and those that don’t. For each platform, its two core frameworks are

essential to any Cocoa project whose end product is an application. Both platforms additionally support the

Core Data framework, which is as important and useful as the core frameworks.

Mac OS X also ships with several other frameworks that publish Cocoa programmatic interfaces, such as the

WebKit and Address Book frameworks; more Cocoa frameworks will be added to the operating system over

time. See “The Cocoa Frameworks” (page 32) for further information.

How Cocoa Fits into Mac OS X

Figure 1-1 shows a simplified diagram of the Mac OS X system architecture.

Figure 1-1 Mac OS X architecture—simplified perspective

Darwin

Quartz OpenGL

QuickTime

Aqua

Carbon

Cocoa

This diagram is simple for a purpose: to depict unambiguously to those unfamiliar with Mac OS X some of

its major components and dependencies. But in its simplicity it omits important details and blurs others.

These details fill in an important part of the picture showing how Cocoa fits into the rest of Mac OS X.

The Cocoa Environment

CHAPTER 1

What Is Cocoa?

Figure 1-2 situates Cocoa more accurately in an architectural setting. This diagram shows Mac OS X as a series

of software layers going from the foundation of Darwin to the various application environments; the

intervening layers represent the system software contained in the two major umbrella frameworks, Core

Services and Application Services. The diagram suggests that a component at one layer generally has

dependencies on the layer beneath it.

Figure 1-2 Cocoa in the architecture of Mac OS X

Kernel environment

Core Services

Application Services

Carbon Cocoa

QuickTime

BSD

In some ways, this diagram is similar to the previous diagram. For example, the system component that is

largely responsible for rendering the Aqua user interface, Quartz (implemented in the Core Graphics

framework), is part of the Application Services layer. And at the base of the architectural stack is Darwin;

everything in Mac OS X, including Cocoa, ultimately depends on Darwin to function.

But if you look closer, at individual or groups of Cocoa classes and at the particular subframeworks of the

umbrella frameworks, you begin to see where Cocoa either has specific dependencies on other parts of Mac

OS X or where it exposes underlying technology with its interfaces. Figure 1-3 charts a few of these

dependencies or exposures.

Figure 1-3 Zooming in on the Cocoa architecture—some major dependencies

Graphics

APIs

File-system

management APIs

Printing

APIs

Foundation

Core

Foundation

Core

Services

Application

Services

Cocoa

Printing

Core

Core Graphics

Quartz

OpenGL

Carbon

Core

QuickTime

Apple has carefully designed Cocoa so that some of its programmatic interfaces give access to the capabilities

of underlying technologies that applications typically need. But if you require some capability that is not

exposed through the programmatic interfaces of Cocoa, or if you need some finer control of what happens

in your application, you may be able to use an underlying framework directly. (A prime example is Core

Graphics; by calling its functions or those of OpenGL, your code can draw more complex and nuanced images

than is possible with the Cocoa drawing methods.) Fortunately, using these lower-level frameworks is not a

problem because the programmatic interfaces of most dependent frameworks are written in standard ANSI

C, of which Objective-C language is a superset.

The Cocoa Environment 17

CHAPTER 1

What Is Cocoa?

Note: The intent of this architectural overview is not to itemize every particular dependency or interface

that Cocoa has on or to other parts of Mac OS X. Instead, it surveys the more interesting ones in order to give

you a general idea of the architectural context of the framework.

The major underlying frameworks on which Cocoa depends or which it exposes through its classes and

methods are Core Foundation, Carbon, Core Graphics (Quartz), Launch Services, and Print Core (the printing

subsystem):

■ Core Foundation. Many classes of the Foundation framework are based on equivalent Core Foundation

opaque types. This close relationship is what makes “toll-free bridging”—cast-conversion between

compatible Core Foundation and Foundation types—possible. Some of the implementation of Core

Foundation, in turn, is based on the BSD part of the Darwin layer.

■ Carbon. Cocoa taps into Carbon for some of the services it provides. This is because various Carbon

frameworks are situated as system-wide services in the Core Services and Application Services layer.

Carbon Core is a particularly important one of these frameworks; for example, it has the File Manager,

which Cocoa uses for conversions between various file-system representations.

■ Core Graphics. The Cocoa drawing and imaging classes are (quite naturally) closely based on the Core

Graphics framework, which implements Quartz and the window server.

■ Launch Services. The NSWorkspace class exposes the underlying capabilities of Launch Services. Cocoa

also uses the application-registration feature of Launch Services to get the icons associated with

applications and documents.

■ Print Core. The Cocoa printing classes present an object-oriented interface to the printing subsystem.

Further Reading: Mac OS X Technology Overview gives an overview of the frameworks, services, technologies,

and other components of Mac OS X. Apple Human Interface Guidelines specifies how the Aqua human interface

should appear and behave.

How Cocoa Fits into iOS

Although the iOS infrastructure on which Cocoa depends is similar to that for Mac OS X, there are some

significant differences. Compare Figure 1-4, which depicts the architectural setting of iOS, to the diagram in

Figure 1-2 (page 17). The iOS diagram also shows the software supporting its platform as a series of layers

going from a Core OS foundation to a set of application frameworks, the most critical (for applications) being

the UIKit framework. As in the Mac OS X diagram, the iOS diagram has middle layers consisting of core-services

frameworks and graphics and audio frameworks and libraries. Here also, a component at one layer often has

dependencies on the layer beneath it.

The Cocoa Environment

CHAPTER 1

What Is Cocoa?

Figure 1-4 Cocoa in the architecture of iOS

Core OS

Core Services

Media

Cocoa Touch

Application

Foundation

UIKit

Core Frameworks

Generally, the system libraries and frameworks of iOS that ultimately support UIKit are a subset of the libraries

and frameworks on Mac OS X. For example, there is no Carbon application environment on iOS, there is no

command-line access (the BSD environment), there are no printing frameworks and services, and QuickTime

is absent from the platform. However, because of the nature of the devices supported by iOS, there are some

frameworks, both public and private, that are specific to iOS.

The following summarizes some of the frameworks found at each layer of the iOS stack, starting from the

foundation layer.

■ Core OS—This level contains the kernel, the file system, networking infrastructure, security, power

management, and a number of device drivers. It also has the libSystem library, which supports the

POSIX/BSD 4.4/C99 API specifications and includes system-level APIs for many services.

■ Core Services—The frameworks in this layer provide core services, such as string manipulation, collection

management, networking, URL utilities, contact management, and preferences. They also provides

services based on hardware features of a device, such as the GPS, compass, accelerometer, and gyroscope.

Examples of frameworks in this layer are Core Location, Core Motion, and System Configuration.

This layer includes both Foundation and Core Foundation, frameworks that provide abstractions for

common data types such as strings and collections. The Core Frameworks layer also contains Core Data,

a framework for object graph management and object persistence

■ Media—The frameworks and services in this layer depend on the Core Services layer and provide graphical

and multimedia services to the Cocoa Touch layer. They include Core Graphics, Core Text, OpenGL ES,

Core Animation, AVFoundation, Core Audio, and video playback.

■ Cocoa Touch—The frameworks in this layer directly support applications based on iOS. They include

frameworks such as Game Kit, Map Kit, and iAd.

The Cocoa Touch layer and the Core Services layer each has an Objective-C framework that is especially

important for developing applications for iOS. These are the core Cocoa frameworks:

■ UIKit framework—provides the objects an application displays in its user interface and defines the

structure for application behavior, including event handling and drawing. For a description of UIKit, see

“UIKit (iOS)” (page 48).

■ Foundation framework—defines the basic behavior of objects, establishes mechanisms for their

management, and provides objects for primitive data types, collections, and operating-system services.

Foundation is essentially an object-oriented cover to the Core Foundation framework; see

“Foundation” (page 33) for a discussion of the Foundation framework.

The Cocoa Environment 19

CHAPTER 1

What Is Cocoa?

Notes: This document uses “Cocoa” generically when referring to things that are common between the

platforms. When it is necessary to say something specific about Cocoa on a given platform, it uses a phrase

such as “Cocoa on Mac OS X.”

For detailed descriptions of the components in the layers of iOS, see iOS Technology Overview.

As with Cocoa on Mac OS X, the programmatic interfaces of Cocoa on iOS give your applications access to

the capabilities of underlying technologies. Usually there will be a Foundation or UIKit method or function

that can tap into a lower-level framework to do what you want. But, as with Cocoa on Mac OS X, if you require

some capability that is not exposed through API, or if you need some finer control of what happens in your

application, you may choose to use an underlying framework directly. For example, UIKit uses the Web Kit

to draw text and publishes some methods for drawing text; however, you may decide to use Core Text to

draw text because that gives you the control you need for text layout and font management. Again, using

these lower-level frameworks is not a problem because the programmatic interfaces of most dependent

frameworks are written in standard ANSI C, of which Objective-C language is a superset.

Further Reading: To learn more about the frameworks, services, and other aspects of the iOS platform, see

iOS Technology Overview.

Features of a Cocoa Application

On Mac OS X it is possible to create a Cocoa application without adding a single line of code. Make a new

Cocoa application project using Xcode and then build the project. That’s it. Of course, this application won’t

do much, or at least much that’s interesting. But this extremely simple application still launches when

double-clicked, displays its icon in the Dock, displays its main menu and window (entitled “Window”), hides

itself on command, behaves nicely with other running applications, and quits on command. You can move,

resize, minimize, and close the window. You can even print the emptiness contained by the window.

You can do the same with an iOS application. Create a project in Xcode using one of the project templates,

immediately build it, and run it in the simulator. It quits when you click the Home button (or press it on a

device). To launch the application, click its icon in the simulator. It may even have additional behaviors; for

example, with an application made from the Utility Application template, the initial view "flips” to a second

view when you click the information (“i”) icon.

Imagine what you could do with a little code.

iOS Note: The features and behavior of an application running on iOS are considerably different from a Mac

OS X application, largely because it runs in a more constrained environment. For discussions of application

capabilities and constraints on iOS, see iOS Application Programming Guide.

In terms of programming effort, Cocoa gives you, the developer, much that is free and much that is low-cost.

Of course, to become a productive Cocoa developer means becoming familiar with possibly new concepts,

design patterns, programming interfaces, and development tools, and this effort is not negligible. But

familiarity yields greater productivity. Programming becomes largely an exercise in assembling the

programmatic components that Cocoa provides along with the custom objects and code that define your

program’s particular logic, then fitting the whole assemblage together.

What follows is a short list of how Cocoa adds value to an application with only a little (and sometimes no)

effort on your part:

Features of a Cocoa Application

CHAPTER 1

What Is Cocoa?

剩余243页未读，继续阅读

Weever

粉丝: 4
资源: 41

Cocoa编程基础指南：探索Cocoa框架

CocoaFundamentals

纽约时报 移动团队 Objective-C 规范指南

秒达开源多功能中文工具箱源码：自部署 全开源 轻量级跨平台 GPT级支持+高效UI+Docker

双极 AMI 的加扰以及 B8ZS 和 HDB3 加扰simulink.rar

C项目开发资源.docx

基于ssm的在线购物系统的设计与实现设计与实现.docx

python-对Excel数据处理做可视化分析.zip

logisim-hust-20200118.zip

springboot小说阅读平台的设计毕业论文.docx

混合动力汽车动态规划算法理论油耗计算与视频教学，使用matlab编写快速计算程序，整个工程结构模块化，可以快速改为串联，并联，混

最新资源

纽约时报移动团队 Objective-C 规范指南

秒达开源多功能中文工具箱源码：自部署全开源轻量级跨平台 GPT级支持+高效UI+Docker