Swift in 24 Hours, Sams Teach Yourself

by BJ Miller

Overview

In just 24 lessons of one hour or less, Sams Teach Yourself Swift in 24 Hours, Second Edition, will teach you how to build next-generation OS X and iOS apps with Apple’s Swift 2 programming language. This book’s straightforward, step-by-step approach helps you quickly master Swift 2’s core concepts, structure, and syntax and use Swift to write safe, powerful, modern code. In just a few hours you’ll be applying features such as extensions, closures, protocols, and generics. Every lesson builds on what you’ve already learned, giving you a rock-solid foundation for real-world success.

Step-by-step instructions carefully walk you through the most common Swift 2 programming tasks.
Practical, hands-on examples show you how to apply what you learn.
Quizzes and exercises help you test your knowledge and stretch your skills.
Notes and tips point out shortcuts and solutions.

Learn how to...

• Get started with Swift 2.0’s Xcode 7 development environment
• Master Swift’s fundamental data types
• Use operators to change, assign, combine, check, or verify values
• Retain data and preferences in memory with arrays, sets, and dictionaries
• Control program flow, modify execution paths, and iterate code
• Perform complex actions concisely with Swift 2.0’s improved functions
• Work with higher-order functions and closures
• Harness the power of structs, enums, classes, and class inheritance
• Take advantage of Swift’s advanced memory allocation and references
• Use protocols to define behavior and explore Protocol-Oriented Programming
• Add type functionality with extensions
• Smoothly handle errors
• Leverage the power of generics to create flexible and reusable code
• Interoperate with Objective-C code
• Get started with Functional Programming approaches and thinking functionally

Product Details

ISBN-13:	9780134387734
Publisher:	Pearson Education
Publication date:	10/29/2015
Series:	Sams Teach Yourself
Sold by:	Barnes & Noble
Format:	eBook
Pages:	464
File size:	21 MB
Note:	This product may take a few minutes to download.

About the Author

BJ Miller is an iOS developer for DXY Solutions, a mobile, web, and design consultancy in the Cleveland, Ohio, area. BJ earned his B.S. in Computer Science from Baldwin-Wallace College (now called Baldwin-Wallace University) in Berea, Ohio, the town where he grew up. His latest career path encompassed large-scale enterprise network administration, SQL database administration, and Microsoft SharePoint Server and Microsoft Project Server administration and integration as a contractor for the United States Department of Defense, with all the Microsoft certifications that come along with that. Before that, he spent several years in LAN engineering, designing and implementing network infrastructure, as a Cisco Certified Network Associate.

BJ began iOS development in 2009 after not having programmed for a few years, and he developed a passion for the platform and the Objective-C language. Now, his love has expanded to include Swift, and there is still yet room in his heart for more. In 2013, he released his first app into the iOS App Store, called MyPrayerMap, as a simple tool for managing prayer requests.

When he is not writing in Objective-C or Swift for either work or this book, he enjoys spending time with his wife and two boys, reading, listening to music or podcasts, and playing The Legend of Zelda (any game on any system will do). He also co-organizes the Cleveland CocoaHeads Meetup with Daniel Steinberg, http://www.meetup.com/Cleveland- CocoaHeads/, and organizes a submeetup of that group called Paired Programming Fun, which is a casual meetup where the focus is on Test-Driven Development (TDD) in Swift in paired-programming style. BJ often presents iOS-related topics at CocoaHeads and also speaks at other conferences such as MacTech, CocoaConf (Columbus, Ohio), and CodeMash v2.0.1.5. He also blogs from time to time at http://bjmiller.me and is on Twitter as @bjmillerltd.

Table of Contents

Introduction     xiv
Who Should Read This Book?      xv
What Should You Expect from This Book?      xvi
HOUR 1: Introducing the Swift Development Environment     1
What Is Swift?      1
Getting Started     2
Summary     10
Q&A     11
Workshop     11
Exercise     12
HOUR 2: Learning Swift’s Fundamental Data Types     13
Constants in Swift     13
Variables in Swift     14
Introducing Data Types     15
Summary     23
Q&A     24
Workshop     24
Exercise     25
HOUR 3: Using Operators in Swift     27
Unary Operators     27
Binary Operators     29
Ternary Conditional Operators     35
Summary     36
Q&A      36
Workshop     37
Exercise     37
HOUR 4: Working with Collection Types     39
Arrays     39
Dictionaries     47
Sets     51
Tuples     55
Summary     56
Q&A     56
Workshop     57
Exercise     57
HOUR 5: Controlling Program Flow with Conditionals     59
The if Statement     59
The switch Statement      64
Summary     73
Q&A     74
Workshop     74
Exercise     75
HOUR 6: Understanding Optional Values     77
What Are Optional Values?      77
How to Designate a Variable as Optional     78
Wrapping and Unwrapping Optional Variables     79
Use Case for Optionals     85
Summary     87
Q&A     87
Workshop     87
Exercise     88
HOUR 7: Iterating Code with Loops     89
Two Categories of Loops     89
Transferring Control in Loops     102
Summary     104
Q&A     104
Workshop     104
Exercise     106
HOUR 8: Using Functions to Perform Actions     107
The Nature of Functions in Swift      108
General Function Syntax and Structure     108
Functions with No Parameters and No Return Type     110
The Type of a Function     110
Functions with Parameters     111
Functions with Variadic Parameters     113
Functions with Return Types     114
External Parameter Names     118
Default Parameter Values     120
Change Argument Values with In-Out Parameters     120
Exiting Early     121
Deferring Execution     122
Summary     123
Q&A     124
Workshop     124
Exercise     125
HOUR 9: Understanding Higher Order Functions and Closures     127
Higher Order Functions     127
Closures     134
Summary     143
Q&A     144
Workshop     144
Exercise     145
HOUR 10: Learning About Structs and Classes     147
Overview of Structs and Classes in Swift     147
What Swift Structs and Classes Have in Common     149
Differences Between Structs and Classes     157
When to Use a Class or a Struct     160
Summary     161
Q&A     161
Workshop     162
Exercise     163
HOUR 11: Implementing Class Inheritance     165
What Is Inheritance?      165
Identifying a Base Class     166
Creating a Subclass     167
Overriding Inherited Methods     169
Accessing super     172
Preventing Overrides     174
Class Identity     176
When to Use Class Inheritance     177
Summary     178
Q&A     179
Workshop     179
Exercise     181
HOUR 12: Harnessing the Power of Enums     183
Understanding Swift Enums     183
Swift Enum Structure     184
Raw Values     185
Enum Shorthand Syntax     187
Associated Values     189
Switching Enum Values     190
Adding Instance Methods to Enums     192
Summary     195
Q&A     195
Workshop     196
Exercise     197
HOUR 13: Customizing Initializers of Classes, Structs, and Enums     199
Initialization     199
Initializing Value Types     201
Advanced Initialization     209
Summary     217
Q&A     218
Workshop     218
Exercise     219
HOUR 14: Digging Deeper with Properties     221
Stored Properties     221
Computed Properties     224
Property Accessors     225
Property Observers     228
Inheriting and Overriding Accessors     231
Inheriting and Overriding Observers     233
Summary     236
Q&A     236
Workshop     237
Exercise     237
HOUR 15: Adding Advanced Type Functionality     239
Type Properties and Methods     239
Type Aliasing     246
Type Access Control     247
Subscripts     249
Type Casting and Non-Specific Types     253
Summary     257
Q&A     258
Workshop     258
Exercise     259
HOUR 16: Understanding Memory Allocation and References     261
Deinitialization     261
Automatic Reference Counting     265
Summary     275
Q&A     276
Workshop     277
Exercise     277
HOUR 17: Using Protocols to Define Behavior     279
Defining Protocols     279
Creating and Adopting Protocols     280
Properties     281
Defining Methods in Protocols     282
Using Protocol Names as Types     284
Adopting and Inheriting Multiple Protocols     285
Optional Protocol Properties and Methods     290
How to Check for Protocol Conformance     291
Using Protocols for Delegation     292
Summary     297
Q&A     298
Workshop     298
Exercise     299
HOUR 18: Using Extensions to Add Type Functionality     301
Defining Extensions     301
Adding Functionality with Extensions     303
Summary     313
Q&A     313
Workshop     313
Exercise     314
HOUR 19: Working with Optional Chaining     315
Defining Optional Chaining     315
Chaining Optional Properties     316
Subscripts     318
Methods     322
Summary     324
Q&A     325
Workshop     325
Exercise     326
HOUR 20: Introducing Generics     327
An Introduction to Generics     327
Type Parameters and Placeholder Types     328
Specifying Type Constraints     329
Creating Generic Types     333
Extending Generic Types     336
Using Associated Types in Protocols     337
Summary     339
Q&A     340
Workshop     340
Exercise     341
HOUR 21: Understanding Protocol-Oriented Programming     343
A Quick Recap of Protocols     343
Implementing Protocols     344
Introducing Protocol Extensions     344
Creating Protocol Extensions     346
What Is and Isn’t Customizable     349
Type Constraints in Protocol Extensions     352
Homogeneous and Heterogeneous Collections     353
Converting Protocol Sequences     355
Summary     357
Q&A     357
Workshop     358
Exercise     359
HOUR 22: Handling Errors     361
Error Handling     361
Swift Error Handling     363
Summary     374
Q&A     375
Workshop     376
Exercise     376
HOUR 23: Adding Interoperability with Objective-C     377
Objective-C Basics     377
Bridging     384
Integrating Swift into an Objective-C App     387
Summary     399
Q&A     399
Workshop     400
Exercise     400
HOUR 24: Functional Thinking in Swift     403
What Is Functional Programming?      403
Thinking in Terms of Functions     404
Summary     418
Q&A     419
Workshop     419
Exercise     420
Index     421