Cocoa框架基础指南

需积分: 10 158 浏览量更新于2024-07-30 收藏 4.39MB PDF 举报

“CocoaFundamentals”是一份关于Cocoa框架的综合指南，由Apple Inc.在2010年12月13日发布。该文档涵盖了Objective-C编程语言和用于iOS、Mac平台的开发知识。 Cocoa是Apple开发的一个核心框架，用于构建 macOS 和 iOS 应用程序。它主要由Objective-C编写，近年来也逐渐融合Swift语言的支持。Cocoa框架包含了大量类库和工具，为开发者提供了构建用户界面、处理事件、管理数据模型以及与其他系统服务交互的能力。 1. **Objective-C基础**： Objective-C是Cocoa框架的基础，是一种面向对象的编程语言，扩展了C语言，添加了Smalltalk风格的消息传递机制。了解类、继承、多态、协议（Protocol）等Objective-C概念对于学习Cocoa至关重要。 2. **Cocoa Touch**：在iOS开发中，Cocoa Touch是主要的框架，它包含了UI元素如UIView、UIButton、UITableView等，以及手势识别和触摸事件处理。通过UIKit，开发者可以构建出丰富的交互式用户界面。 3. **Cocoa**：对于macOS开发，Cocoa框架包含了AppKit、Foundation和其他关键组件。AppKit提供用户界面元素，如NSWindow、NSView、NSButton等，而Foundation框架则包含基础数据类型、集合类、线程管理、网络编程等核心功能。 4. **Model-View-Controller (MVC)**： MVC设计模式是Cocoa的核心架构，将应用程序逻辑分为模型（Model）、视图（View）和控制器（Controller）三部分，实现数据和界面的分离，便于代码管理和维护。 5. **Core Data**： Apple的Core Data是用于管理应用程序数据模型的强大工具，支持对象关系映射，简化数据存储和检索。通过Core Data，开发者可以创建数据模型，处理数据库事务，并与用户界面进行绑定。 6. **Event Handling**： Cocoa中的事件处理机制基于NSResponder链，允许应用程序响应用户的输入，如点击、拖拽等。这个系统包括了键盘、鼠标和触摸事件的处理。 7. **Binding and KVO**： Cocoa绑定（Cocoa Bindings）和键值观察（Key-Value Observing, KVO）是Cocoa中用于对象间通信的技术，简化了数据模型与用户界面之间的同步。 8. **Interface Builder**： Xcode的Interface Builder是与Cocoa紧密集成的可视化设计工具，允许开发者通过拖放方式构建用户界面，并与代码逻辑进行连接。 9. **Delegates and Notifications**：在Cocoa中，代理（Delegate）和通知（Notification）是两种主要的通信机制，用于对象间的通信和事件响应。 10. **Memory Management**：在Objective-C时代，Cocoa使用引用计数来管理内存，引入了ARC（Automatic Reference Counting），自动处理大部分内存管理问题，减少内存泄漏的风险。 11. **Blocks and Grand Central Dispatch (GCD)**： Blocks是Objective-C的一种语法特性，允许定义可嵌套的匿名函数。GCD是Apple的并发编程框架，利用Blocks简化了多线程任务的处理。 12. **Auto Layout and Size Classes**： Auto Layout允许开发者定义界面元素之间的约束，以适应不同屏幕尺寸和设备方向。Size Classes引入了灵活的布局系统，支持不同屏幕尺寸的iOS和macOS应用设计。 CocoaFundamentals指南详细介绍了使用Objective-C和Cocoa框架开发iOS及Mac应用的基础知识和最佳实践。这份文档是开发者入门和进阶的重要参考资料，提供了Apple官方的权威指导。

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

Note: The intent of this architectural overview is not to itemize every relationship that Cocoa has 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.

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.

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

The application-framework layer of iOS is called Cocoa Touch. Although the iOS infrastructure on which

Cocoa Touch depends is similar to that for Cocoa in Mac OS X, there are some significant differences. Compare

Figure 1-2, which depicts the architectural setting of iOS, to the diagram in Figure 1-1 (page 15). 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 media frameworks and libraries. Here also, a component at one layer often has dependencies on the

layer beneath it.

Figure 1-2 Cocoa in the architecture of iOS

Core OS

Core Services

Media

Cocoa Touch

Application

Foundation

UIKit

Core Frameworks

The Cocoa Environment

CHAPTER 1

What Is Cocoa?

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

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

command-line access (the BSD environment in Darwin), 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 provide 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 in 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 in iOS:

● UIKit. This 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 44).

● Foundation. This 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 version of the Core Foundation framework; see

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

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 in Mac OS X.”

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

capabilities of underlying technologies. Usually there is a Foundation or UIKit method or function that can

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

capability that is not exposed through a Cocoa 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 WebKit

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

The Cocoa Environment 17

CHAPTER 1

What Is Cocoa?

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

In Mac OS X it is possible to create a Cocoa application without adding a single line of code. You 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 menus and window (titled “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 iOS Simulator. The application quits when you click the Home button

(or press it on a device). To launch the application, click its icon in 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 or tap the information (“i”) icon.

Imagine what you could do with a little code.

iOS Note: The features and behavior of an application running in 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 in 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 everything 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:

● Basic application framework—Cocoa provides the infrastructure for event-driven behavior and for

management of applications, windows, and (in the case of Mac OS X) workspaces. In most cases, you

won’t have to handle events directly or send any drawing commands to a rendering library.

● User-interface objects—Cocoa offers a rich collection of ready-made objects for your application’s user

interface. Most of these objects are available in the library of Interface Builder, a development application

for creating user interfaces; you simply drag an object from the library onto the surface of your interface,

configure its attributes, and connect it to other objects. (And, of course, you can always instantiate,

configure, and connect these objects programmatically.)

Here is a sampling of Cocoa user-interface objects:

Features of a Cocoa Application

CHAPTER 1

What Is Cocoa?

●

Windows

●

Text fields

●

Image views

●

Date pickers

●

Sheets and dialogs

●

Segmented controls

●

Table views

●

Progress indicators

●

Buttons

●

Sliders

●

Radio buttons (Mac OS X)

●

Color wells (Mac OS X)

●

Drawers (Mac OS X)

●

Page controls (iOS)

●

Navigation bars (iOS)

●

Switch controls (iOS)

Cocoa in Mac OS X also features technologies that support user interfaces, including those that promote

accessibility, perform validation, and facilitate the connections between objects in the user interface and

custom objects.

● Drawing and imaging—Cocoa enables efficient drawing of custom views with a framework for locking

graphical focus and marking views (or portions of views) as “dirty.” Cocoa includes programmatic tools

for drawing Bezier paths, performing affine transforms, compositing images, generating PDF content,

and (in Mac OS X) creating various representations of images.

● System interaction—In Mac OS X, Cocoa gives your application ways to interact with (and use the

services of) the file system, the workspace, and other applications. In iOS, Cocoa lets you pass URLs to

applications to have them handle the referenced resource (for example, email or websites); it also provides

support for managing user interactions with files in the local system and for scheduling local notifications.

● Performance—To enhance the performance of your application, Cocoa provides programmatic support

for concurrency, multithreading, lazy loading of resources, memory management, and run-loop

manipulation.

● Internationalization—Cocoa provides a rich architecture for internationalizing applications, making it

possible for you to support localized resources such as text, images, and even user interfaces. The Cocoa

approach is based on users’ lists of preferred languages and puts localized resources in bundles of the

application. Based on the settings it finds, Cocoa automatically selects the localized resource that best

Features of a Cocoa Application 19

CHAPTER 1

What Is Cocoa?

matches the user’s preferences. It also provides tools and programmatic interfaces for generating and

accessing localized strings. Moreover, text manipulation in Cocoa is based on Unicode by default, and

is thus an asset for internationalization.

● Text—In Mac OS X, Cocoa provides a sophisticated text system that allows you to do things with text

ranging from the simple (for example, displaying a text view with editable text) to the more complex,

such as controlling kerning and ligatures, spell checking, regular expressions, and embedding images

in text. Although Cocoa in iOS has no native text system (it uses WebKit for string drawing) and its text

capabilities are more limited, it still includes support for spellchecking, regular expressions, and interacting

with the text input system.

● Preferences—The user defaults system is based on a systemwide database in which you can store global

and application-specific preferences. The procedure for specifying application preferences is different

for Mac OS X and iOS.

● Networking—Cocoa also offers programmatic interfaces for communicating with servers using standard

Internet protocols, communicating via sockets, and taking advantage of Bonjour, which lets your

application publish and discover services on an IP network.

In Mac OS X, Cocoa includes a distributed objects architecture that allows one Cocoa process to

communicate with another process on the same computer or on a different one. In iOS, Cocoa supports

the capability for servers to push notifications to devices for applications registered to received such

notifications.

● Printing—Cocoa on both platforms supports printing. Their printing architecture lets you print images,

documents, and other application content along a range of control and sophistication. At the simplest

level, you can print the contents of any view or print an image or PDF document with just a little code.

At a more complicated level, you can define the content and format of printed content, control how a

print job is performed, and do pagination. In Mac OS X, you can add an accessory view to the Print dialog.

● Undo management—You can register user actions that occur with an undo manager, and it will take

care of undoing them (and redoing them) when users choose the appropriate menu items. The manager

maintains undo and redo operations on separate stacks.

● Multimedia—Both platforms programmatically support video and audio. In Mac OS X, Cocoa offers

support for QuickTime video.

● Data exchange—Cocoa simplifies the exchange of data within an application and between applications

using the copy-paste model. In Mac OS X, Cocoa also supports drag-and-drop models and the sharing

of application capabilities through the Services menu.

Cocoa in Mac OS X has a couple of other features:

● Document-based applications—Cocoa specifies an architecture for applications composed of a potentially

unlimited number of documents, with each contained in its own window (a word processor, for example).

Indeed, if you choose the “Document-based application” project type in Xcode, many of the components

of this sort of application are created for you.

● Scripting— Through application scriptability information and a suite of supporting Cocoa classes, you

can make your application scriptable; that is, it can respond to commands emitted by AppleScript scripts.

Applications can also execute scripts or use individual Apple events to send commands to, and receive

data from, other applications. As a result, every scriptable application can supply services to both users

and other applications.

Features of a Cocoa Application

CHAPTER 1

What Is Cocoa?

剩余199页未读，继续阅读

parkerlau

粉丝: 2

Cocoa框架基础指南

Cocoa框架基础与Objective-C应用详解

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

CocoaFundamentals.pdf

java计算器源码.zip

FRP Manager-V1.19.2

基于优化EKF的PMSM无位置传感器矢量控制研究_崔鹏龙.pdf

旧物置换网站(基于springboot,mysql,java).zip

上位机开发，对桥梁、环境等传感器传输的数据进行采集并入库，以便用于系统平台对数据进行处理分析(毕设&课设&实训&大作业&竞赛&项目)

质子号.zip

两级式单相光伏并网仿真研究：MATLAB 2021a版本下的DC-DC变换与桥式逆变技术实现功率跟踪与并网效果优化,基于Matlab 2021a的两级式单相光伏并网仿真研究：实现最大功率跟踪与稳定的直

最新资源