Swift 2.0与iOS 9开发基础

需积分: 10 186 浏览量更新于2024-07-21 收藏 4.33MB PDF 举报

"iOS 9 Programming Fundamentals with Swift - Swift, Xcode, and Cocoa Basics - iOS 9 Swift" 《iOS 9编程基础与Swift》是一本针对iOS开发初学者的指南，详细介绍了使用Swift语言、Xcode集成开发环境（IDE）以及Cocoa基础框架构建iOS应用的全过程。这本书专门涵盖了iOS 9、Xcode 7和Swift 2.0的最新内容，为读者提供了一个全面了解iOS开发的平台。 Swift是苹果公司推出的一种现代化、安全且高效的编程语言，它简化了Objective-C的语法，同时引入了许多创新特性，如类型推断、泛型、可选值等。在本书中，读者将深入学习Swift的面向对象概念，如类、结构体、枚举、协议、扩展以及闭包等，理解这些核心概念对于编写高质量的iOS应用至关重要。 Xcode是苹果官方的开发工具，包含了一整套用于创建iOS和macOS应用程序的工具，包括源代码编辑器、调试器、模拟器和Interface Builder。书中会介绍如何使用Xcode进行项目设置、界面设计、代码编写和调试，帮助开发者快速上手iOS应用的开发流程。 Cocoa Touch是iOS应用程序的基础框架，提供了许多UI组件和系统服务，如视图控制器、按钮、滑块、标签、表格视图等。通过Cocoa Touch，开发者可以构建用户交互丰富的应用界面。本书将深入探讨如何利用Cocoa Touch的API实现常见的用户交互和动画效果，以及如何处理网络请求、数据存储和多媒体操作。此外，书中还会讲解如何使用Storyboard进行界面布局，这是一种可视化设计工具，可以帮助开发者直观地构建应用的屏幕流程。同时，也会涵盖Apple的Auto Layout和Size Classes技术，这些技术使得应用能够在不同尺寸的设备上自动适配。通过《iOS 9编程基础与Swift》，读者不仅可以学习到Swift编程语言的基本语法，还将学会如何利用Xcode和Cocoa Touch开发出功能齐全、用户友好的iOS应用程序。无论你是编程新手还是想要转型为iOS开发的专业人士，这本书都能提供你需要的知识和实践经验，帮助你在iOS开发领域奠定坚实的基础。

Memory management

Swift manages memory automatically. You will rarely have to concern yourself with

memory management.

Cocoa compatibility

The Cocoa APIs are written in C and Objective-C. Swift is explicitly designed to

interface with most of the Cocoa APIs.

These features make Swift an excellent language for learning to program iOS.

The alternative, Objective-C, still exists, and you can use it if you like. Indeed, it is easy

to write an app that includes both Swift code and Objective-C code; and you may have

reason to do so. Objective-C, however, lacks the very advantages that Swift offers.

Objective-C agglomerates object-oriented features onto C. It is therefore only partially

object-oriented; it has both objects and scalar data types, and its objects have to be slotted

into one particular C data type (pointers). Its syntax can be difficult and tricky; reading

and writing nested method calls can make one’s eyes glaze over, and it invites hacky

habits such as implicit nil-testing. Its type checking can be and frequently is turned off,

resulting in programmer errors where a message is sent to the wrong type of object and

the program crashes. It uses manual memory management; the recent introduction of

ARC (automatic reference counting) has alleviated some of the programmer tedium

and has greatly reduced the likelihood of programmer error, but errors are still possible,

and memory management ultimately remains manual.

Recent revisions and additions to Objective-C — ARC, synthesis and autosynthesis,

improved literal array and dictionary syntax, blocks — have made it easier and more

convenient, but such patches have also made the language even larger and possibly even

more confusing. Because Objective-C must encompass C, there are limits to how far it

can be extended and revised. Swift, on the other hand, is a clean start. If you were to

dream of completely revising Objective-C to create a better Objective-C, Swift might be

what you would dream of. It puts a modern, rational front end between you and the

Cocoa Objective-C APIs.

Therefore, Swift is the programming language used throughout this book. Nevertheless,

the reader will also need some awareness of Objective-C (including C). The Foundation

and Cocoa APIs, the built-in commands with which your code must interact in order

to make anything happen on an iOS device, are still written in C and Objective-C. In

order to interact with them, you have to know what those languages would expect. For

example, in order to pass a Swift array where an NSArray is expected, you need to know

what consitutes an object acceptable as an element of an Objective-C NSArray.

Therefore, in this edition, although I do not attempt to teach Objective-C, I do describe

it in enough detail to allow you to read it when you encounter it in the documentation

and on the Internet, and I occasionally show some Objective-C code. Part III, on Cocoa,

is really all about learning to think the way Objective-C thinks — because the structure

and behavior of the Cocoa APIs are fundamentally based on Objective-C. And the book

xiv | Preface

ends with an appendix that details how Swift and Objective-C communicate with one

another

, as well as detailing how your app can be written partly in Swift and partly in

Objective-C.

The Scope of This Book

This book is actually one of a pair with my Programming iOS 9, which picks up exactly

where this book leaves off. They complement and supplement one another. The two-

book architecture should, I believe, render the size and scope of each book tractable for

readers. Together, they provide a complete grounding in the knowledge needed to begin

writing iOS apps; thus, when you do start writing iOS apps, you’ll have a solid and

rigorous understanding of what you are doing and where you are heading. If writing

an iOS program is like building a house of bricks, this book teaches you what a brick is

and how to handle it, while Programming iOS 9 hands you some actual bricks and tells

you how to assemble them.

When you have read this book, you’ll know about Swift, Xcode, and the underpinnings

of the Cocoa framework, and you will be ready to proceed directly to Programming iOS

9. Conversely, Programming iOS 9 assumes a knowledge of this book; it 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. If you started reading Programming iOS 9 and wondered about

such unexplained matters as Swift language basics, the UIApplicationMain function,

the nib-loading mechanism, Cocoa patterns of delegation and notification, and retain

cycles, wonder no longer — I didn’t explain them there because I do explain them here.

The three parts of this book teach the underlying basis of all iOS programming:

• Part I introduces the Swift language, from the ground up — I do not assume that

you know any other programming languages. My way of teaching Swift is different

from other treatments, such as Apple’s; it is systematic and Euclidean, with peda‐

gogical building blocks piled on one another in what I regard as the most helpful

order. At the same time, I have tried to confine myself to the essentials. Swift is not

a big language, but it has some subtle and unusual corners. You don’t need to dive

deep into all of these, and my discussion will leave many of them unexplored. You

will probably never encounter them, and if you do, you will have entered an ad‐

vanced Swift world outside the scope of this discussion. To give an obvious example,

readers may be surprised to find that I never mention Swift playgrounds or the

REPL. My focus here is real-life iOS programming, and my explanation of Swift

therefore concentrates on those common, practical aspects of the language that, in

my experience, actually come into play in the course of programming iOS.

• Part II turns to Xcode, the world in which all iOS programming ultima

tely takes

place. It explains 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

Preface | xv

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

the subsequen

t 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, such

specialized topics as autolayout constraints in the nib are postponed to the other

book.

• Part III introduces the Cocoa Touch framework. When you program for iOS, you

take advantage of a suite of frameworks provided by Apple. These frameworks,

taken together, constitute Cocoa; the brand of Cocoa that provides the API for

programming iOS is Cocoa Touch. Your code will ultimately be almost entirely

about communicating with Cocoa. The Cocoa Touch frameworks provide the un‐

derlying functionality that any iOS app needs to have. But to use a framework, you

have to think the way the framework thinks, put your code where the framework

expects it, and fulfill many obligations imposed on you by the framework. To make

things even more interesting, Cocoa uses Objective-C, while you’ll be using Swift:

you need to know how your Swift code will interface with Cocoa’s features and

behaviors. Cocoa 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. Key–value coding

and key–value observing are also discussed here.

The reader of this book will thus get a thorough grounding in the fundamental knowl‐

edge and techniques that any good iOS programmer needs. The book itself doesn’t show

how to write any particularly interesting iOS apps, but it does constantly use my own

real apps and real programming situations to illustrate and motivate its explanations.

And then you’ll be ready for Programming iOS 9, of course!

Versions

This book is geared to Swift 2.0, iOS 9, and Xcode 7.

In general, only very minimal attention is given to earlier versions of iOS and Xcode. It

is not my intention to embrace in this book any detailed knowledge about earlier ver‐

sions of the software, which is, after all, readily and compendiously available in my

earlier books. The book does contain, nevertheless, a few words of advice about back‐

ward compatibility (especially in Chapter 9).

The Swift language included with Xcode 7, Swift 2.0, has changed very significantly

from its immediate predecessor, Swift 1.2. If you were using Swift 1.2 previously, you’ll

almost certainly find that your code won’t compile with Swift 2.0 without some thorough

revision. Similarly, the code in this book, being written in Swift 2.0, is totally incom‐

patible with Swift 1.2. On the assumption that you might have some prior knowledge

of Swift 1.2, I call out, in the course of my discussion, most of the important language

features that are new or changed in Swift 2.0. But I do not describe or explain Swift 1.2

xvi | Preface

at all; if you need to know about it — though I can’t imagine why you would — consult

the previous edition of this book.

cknowledgments

My thanks go first and foremost to the people at O’Reilly Media who have made writing

a book so delightfully easy: Rachel Roumeliotis, Sarah Schneider, Kristen Brown, Dan

Fauxsmith, and Adam Witwer come particularly to mind. And let’s not forget my first

and long-standing editor, Brian Jepson, who had nothing whatever to do with this ed‐

ition, but whose influence is present throughout.

As in the past, I have been greatly aided by some fantastic software, whose excellences

I have appreciated at every moment of the process of writing this book. I should like to

mention, in particular:

• git (http://git-scm.com)

• SourceTree (http://www.sourcetreeapp.com)

• TextMate (http://macromates.com)

• AsciiDoc (http://www.methods.co.nz/asciidoc)

• BBEdit (http://barebones.com/products/bbedit/)

• Snapz Pro X (http://www.ambrosiasw.com)

• GraphicConverter (http://www.lemkesoft.com)

• OmniGraffle (http://www.omnigroup.com)

The book was typed and edited en

tirely on my faithful Unicomp Model M keyboard

(http://pckeyboard.com), without which I could never have done so much writing over

so long a period so painlessly. For more about my physical work environment, see http://

matt.neuburg.usesthis.com.

From the Programming iOS 4 Preface

A programming framework has a kind of personality, an overall flavor that provides an

insight into the goals and mindset of those who created it. When I first encountered

Cocoa Touch, my assessment of its personality was: “Wow, the people who wrote this

are really clever!” On the one hand, the number of built-in interface objects was severely

and deliberately limited; on the other hand, the power and flexibility of some of those

objects, especially such things as UITableView, was greatly enhanced over their OS X

counterparts. Even more important, Apple created a particularly brilliant way (UIView‐

Controller) to help the programmer make entire blocks of interface come and go and

supplant one another in a controlled, hierarchical manner, thus allowing that tiny

Preface | xvii

iPhone display to unfold virtually into multiple interface worlds within a single app

without the user becoming lost or confused.

The popularity of the iPhone, with its largely free or ver

y inexpensive apps, and the

subsequent popularity of the iPad, have brought and will continue to bring into the fold

many new programmers who see programming for these devices as worthwhile and

doable, even though they may not have felt the same way about OS X. Apple’s own annual

WWDC developer conventions have reflected this trend, with their emphasis shifted

from OS X to iOS instruction.

The widespread eagerness to program iOS, however, though delightful on the one hand,

has also fostered a certain tendency to try to run without first learning to walk. iOS gives

the programmer mighty powers that can seem as limitless as imagination itself, but it

also has fundamentals. I often see questions online from programmers who are evidently

deep into the creation of some interesting app, but who are stymied in a way that reveals

quite clearly that they are unfamiliar with the basics of the very world in which they are

so happily cavorting.

It is this state of affairs that has motivated me to write this book, which is intended to

ground the reader in the fundamentals of iOS. I love Cocoa and have long wished to

write about it, but it is iOS and its popularity that has given me a proximate excuse to

do so. Here I have attempted to marshal and expound, in what I hope is a pedagogically

helpful and instructive yet ruthlessly Euclidean and logical order, the principles and

elements on which sound iOS programming rests. My hope, as with my previous books,

is that you will both read this book cover to cover (learning something new often enough

to keep you turning the pages) and keep it by you as a handy reference.

This book is not intended to disparage Apple’s own documentation and example

projects. They are wonderful resources and have become more wonderful as time goes

on. I have depended heavily on them in the preparation of this book. But I also find that

they don’t fulfill the same function as a reasoned, ordered presentation of the facts. The

online documentation must make assumptions as to how much you already know; it

can’t guarantee that you’ll approach it in a given order. And online documentation is

more suitable to reference than to instruction. A fully written example, no matter how

well commented, is difficult to follow; it demonstrates, but it does not teach.

A book, on the other hand, has numbered chapters and sequential pages; I can assume

you know views before you know view controllers for the simple reason that Part I

precedes Part II. And along with facts, I also bring to the table a degree of experience,

which I try to communicate to you. Throughout this book you’ll find me referring to

“common beginner mistakes”; in most cases, these are mistakes that I have made myself,

in addition to seeing others make them. I try to tell you what the pitfalls are because I

assume that, in the course of things, you will otherwise fall into them just as naturally

as I did as I was learning. You’ll also see me construct many examples piece by piece or

extract and explain just one tiny portion of a larger app. It is not a massive finished

xviii | Preface

剩余603页未读，继续阅读

dennis85

粉丝: 1
资源: 26

Swift 2.0与iOS 9开发基础

IOS 11 Programming Fundamentals with Swift

iOS 11 Programming Fundamentals with Swift Swift, Xcode, and Cocoa Basics azw3

学习ios有哪些好的书籍

【数字逻辑fundamentals of digital logic with verilog design | 3rd editio

编写函数实现对字符串Fundamentals and applications of python programming加密和解密，循环使用密钥A basic professional course，并采用简单的异或算法。使用python编写

Fundamentals of Physics. Extended

Microsoft Certified： Fundamentals

digital fundamentals10 pdf

text: fundamentals of digital logic with verilog design, third edition,

数字逻辑fundamentals of digital logic with verilog design | 3rd edition solu

最新资源