iOS 7编程基础与实战指南

5星 · 超过95%的资源需积分: 10 30 浏览量更新于2024-07-24 4 收藏 11.97MB PDF 举报

"Programming.iOS.7(4th,2013.12)".Matt.Neuburg.文字版.pdf 本书是《Programming iOS 7》的第四版，由Matt Neuburg撰写，主要关注Apple的iOS 7操作系统。随着iOS的不断升级，从iOS 4到iOS 6，本书的内容也在逐渐增加，每一版的页数分别达到了约800页、950页和1150页。然而，iOS 7带来了更多的新特性，因此作者决定对书籍进行大规模的改版。他将原书分为两部分： 1. 一本新的书籍《iOS 7 Programming Fundamentals》，包含了前三个版本的第1到第13章。 2. 本《Programming iOS 7》书籍，涵盖了前三个版本的第14到第40章。这本书针对的是iOS 7的开发人员，旨在详细介绍如何在新的操作系统上进行编程。书中内容可能包括但不限于：UIKit框架的更新，新的设计语言，多任务处理，控制中心，通知中心，自动布局，以及苹果在iOS 7中引入的其他开发者工具和API。作者Matt Neuburg在编写过程中，可能深入讨论了Objective-C编程语言的基础，Cocoa Touch框架，以及如何利用Xcode IDE来创建和调试应用程序。此外，书中可能还涉及到了Core Data的使用，网络编程，多媒体处理，游戏开发，以及如何利用iOS 7的新特性来提升用户体验。编辑Rachel Roumeliotis，生产编辑Kristen Brown，校对员O'Reilly Production Services，索引编制者Matt Neuburg，封面设计师Randy Comer，内页设计师David Futato，插图画家仍然是作者本人，共同参与了这本书的制作过程。自2011年第一版以来，本书经历了多次更新，以适应iOS系统的持续变化。第四版的发布日期为2013年12月，读者可以通过O'Reilly的网站获取错误报告和详细更新信息。本书不仅适合初学者，也适合有一定经验的iOS开发者，帮助他们掌握iOS 7开发的最新技术和最佳实践。

Aut lego vel scribo; doceo scrutorve sophian.

—Sedulius Scottus

Preface

This book, now in its fourth edition, has grown in size to encompass the growth in its

subject, until it can grow no more. The previous editions — Programming iOS 4 (May

2011), Programming iOS 5 (March 2012), and Programming iOS 6 (March 2013) — were

approximately 800 pp., 950 pp., and 1150 pp. in length, respectively, not because I had

more to say each time, but because Apple, as it added features to iOS 4 to make iOS 5,

and to iOS 5 to make iOS 6, had given me more to describe.

Now iOS 7 has come along with even more new features, and drastic action was needed.

Accordingly, the book has been ripped violently but neatly in two — neatly, because

there was already a perfectly natural place to do the ripping, namely right after the end

of what used to be Part III (Chapter 13). There are now two books:

• A new book, iOS 7 Programming Fundamentals, comprising chapters 1–13 of the

earlier books.

• This book, Programming iOS 7, comprising chapters 14–40 of the earlier books.

The truth is that this is a division I had wanted to make even before Programming iOS

4 was published — indeed, before it was even conceived of. My original proposal to

O’Reilly Media, back in early 2010, had been for a book to be called Fundamentals of

Cocoa Programming, intended to cover very much the same material as iOS 7 Program‐

ming Fundamentals covers now. But the proposal was accepted only on condition that

it be extended to cover much more of Cocoa Touch (iOS) programming; so I complied

and set to work on this longer project, and later, despite my impassioned pleas in the

autumn of 2010, I was unable to persuade the publisher to break up the lengthy manu‐

script into two: by that time, all the king’s horses and all the king’s men could no longer

crack Humpty Dumpty apart.

The new situation, therefore, is just what I always wanted in the first place — but not

quite, because what I most desired was a single book in two volumes. My idea was that

the books would have the same title, distinguished as Volume I and Volume II, with

successive numbering of pages and chapters: if Volume I ended, say, with Chapter 13

and page 400, then Volume II would start with Chapter 14 and page 401. To this de‐

lightfully Victorian extreme, I’m sorry to say, O’Reilly Media were implacably opposed.

Thus, Programming iOS 7, though it starts with its own Chapter 1 and page 1, never‐

theless still picks up exactly where iOS 7 Programming Fundamentals leaves off. They

complement and supplement one another. Those who desire a complete grounding in

the knowledge needed to begin writing iOS apps with a solid and rigorous understand‐

ing of what they are doing and where they are heading will, I hope, obtain both books.

At the same time, the two-book architecture should, I believe, render the size and scope

of each book individually more acceptable and attractive to more readers.

Those who feel that they know already all there is to know about C, Objective-C, Xcode,

and the linguistic and architectural basis of the Cocoa framework, or who are content

to pick up such underpinnings as they go along, need no longer (as some in the past

have done) complain that the book is occupied with 13 preliminary chapters before the

reader starts really writing any significant iOS code, because those 13 chapters have now

been abstracted into a separate volume, iOS 7 Programming Fundamentals, and this

book, Programming iOS 7, now begins, like Homer’s Iliad, in the middle of the story,

with the reader jumping with all four feet into views and view controllers, and with a

knowledge of the language and the Xcode IDE already presupposed. And if such a reader

subsequently changes his or her mind and decides that a thorough grounding in those

underpinnings might in fact be desirable, iOS 7 Programming Fundamentals will still

be available and awaiting study.

Moreover, the existence of iOS 7 Programming Fundamentals means that I, as author

and teacher, can make the same assumption in this edition about you, as reader and

student, that I made in previous editions — namely, that you have a command of the

material in that book. If you find yourself mystified by terminology or concepts used in

this book, then it might be wise to stop reading it and take up iOS 7 Programming

Fundamentals first! In it, I explain such things as:

• The Objective-C language, starting with C and building up to the object-oriented

concepts and mechanics of classes and instances in Objective-C itself.

• Xcode, the world in which all iOS programming ultimately takes place, including

what an Xcode project is and how it is transformed into an app, and how to work

comfortably and nimbly with Xcode to consult the documentation and to write,

navigate, and debug code, as well as how to bring your app through the subsequent

stages of running on a device and submission to the App Store. There is also a very

important chapter on nibs and the nib editor (Interface Builder), including outlets

and actions as well as the mechanics of nib loading. (However, some additional

important nib-related topics, such as autolayout constraints and storyboard segues,

are discussed in this book.)

xvi | Preface

• The Cocoa Touch framework, which provides important foundational classes and

adds linguistic and architectural devices such as categories, protocols, delegation,

and notifications, as well as the pervasive responsibilities of memory management,

plus key–value coding and key–value observing.

With those basics having been laid down in iOS 7 Programming Fundamentals, this

book, Programming iOS 7, assumes that you already know Objective-C and how to work

with Xcode to edit code and nibs, make properties and outlets and actions, and so forth,

and proceeds to explain the constituents of practical iOS app construction:

• Part I describes views, the fundamental units of an iOS app’s interface. Views are

what the user can see and touch in an iOS app. To make something appear before

the user’s eyes, you need a view. To let the user interact with your app, you need a

view. This part of the book explains how views are created, arranged, drawn, layered,

animated, and touched.

• Part II starts by discussing view controllers. Perhaps the most remarkable and im‐

portant feature of iOS programming, view controllers enable views to come and go

coherently within the interface, thus allowing a single-windowed app running on

what may be a tiny screen to contain multiple screens of material. This part of the

book talks about all the ways in which view controllers can be manipulated in order

to make their views appear. It also describes every kind of view provided by the

Cocoa framework — the built-in “widgets” with which you’ll construct an app’s

interface.

• Part III surveys many of the secondary frameworks provided by iOS. These are

clumps of code, sometimes with built-in interface, that are not part of your app by

default, but are there for the asking if you need them, allowing you to work with

such things as sound, video, user libraries, mail, maps, and the device’s sensors.

•

Part IV wraps up the book with some miscellaneous but important topics: files,

networking, threading, and how to implement Undo and Redo.

• Appendix A summarizes the most important lifetime event messages sent to your

app delegate.

Someone who has read this book (and who, it goes without saying, is conversant with

the material in iOS 7 Programming Fundamentals) will, I believe, be capable of writing

a real-life iOS app, and to do so with a clear understanding of what he or she is doing

and where the app is going as it grows and develops. The book itself doesn’t show how

to write any particularly interesting iOS apps (though it is backed by dozens of example

projects that you can download from my GitHub site, http://github.com/mattneub/

Programming-iOS-Book-Examples), but it does constantly use my own real apps and

real programming situations to illustrate and motivate its explanations.

Just as important, this book is intended to prepare you for your own further explorations.

In the case of some topics, especially in Part III and Part IV, I guide you past the initial

Preface | xvii

barrier of no knowledge into an understanding of the topic, its concepts, its capabilities,

and its documentation, along with some code examples; but the topic itself may be so

huge that there is room only to introduce it here. Your feet, nevertheless, will now be

set firmly on the path, and you will know enough that you can now proceed further

down that path on your own whenever the need or interest arises.

Indeed, there is always more to learn about iOS. iOS is vast! It is all too easy to find areas

of iOS that have had to be ruled outside the scope of this book. In Part IV, for example,

I peek at Core Data, and demonstrate its use in code, but a true study of Core Data would

require an entire book of its own (and such books exist); so, having opened the door, I

quickly close it again, lest this book suddenly double in size. By the same token, many

areas of iOS are not treated at all in this book:

OpenGL

An open source C library for drawing, including 3D drawing, that takes full ad‐

vantage of graphics hardware. This is often the most efficient way to draw, especially

when animation is involved. iOS incorporates a simplified version of OpenGL called

OpenGL ES. See Apple’s OpenGL Programming Guide for iOS. Open GL interface

configuration, texture loading, shading, and calculation are simplified by the GLKit

framework; see the GLKit Framework Reference.

Sprite Kit

New in iOS 7, Sprite Kit provides a built-in framework for designing 2D animated

games.

Accelerate

Certain computation-intensive processes will benefit from the vector-based Accel‐

erate framework. See the vDSP Programming Guide.

Game Kit

The Game Kit framework covers three areas that can enhance your user’s game

experience: Wireless or Bluetooth communication directly between devices (peer-

to-peer); voice communication across an existing network connection; and Game

Center, which facilitates these and many other aspects of interplayer communica‐

tion, such as posting and viewing high scores and setting up combinations of players

who wish to compete. See the Game Kit Programming Guide.

Advertising

The iAD framework lets your free app attempt to make money by displaying ad‐

vertisements provided by Apple. See the iAD Programming Guide.

Newsstand

Your app may represent a subscription to something like a newspaper or magazine.

See the Newsstand Kit Framework Reference.

Printing

See the “Printing” chapter of the Drawing and Printing Guide for iOS.

xviii | Preface

剩余928页未读，继续阅读

攻城无数

粉丝: 178
资源: 44

iOS 7编程基础与实战指南

[Programming.iOS.5(2nd,2012.3)].Matt.Neuburg.文字版.pdf

[Programming.iOS.5(2nd.2012.01,Early.Release)].Matt.Neuburg.文字版.epub

Programming.iOS.9.2015.11.pdf

Programming.iOS.5.2nd.Edition.pdf

[iOS 7 Programming Fundamentals 2013 10 ] Matt Neuburg 文字版 pdf

Programming.iOS.6

Programming.iOS.9.2015.11

Programming iOS 7, 4th Edition - 2013.pdf

Programming iOS 11 by Matt Neuburg

Programming iOS 11 - Matt Neuburg

最新资源