Sams Teach Yourself Objective-C in 24 Hours

Jesse Feiler is a developer and author. He has been an Apple developer since before it became fashionable, and has worked with mobile devices starting with Apple's Newton and continuing with the iOS products (iPhone, iPod touch, and iPad). His books include Sams Teach Yourself Core Data in 24 Hours, Data-Driven iOS Apps for iPad and iPhone with FileMaker Pro, FileMaker Pro in Depth (Sams/Pearson), Database-Driven Web Sites (Harcourt), Learning iCloud Data Management (Addison Wesley/Pearson), and iOS App Development for Dummies (Wiley). He has written about Objective-C and the Apple frameworks beginning with Rhapsody Developer's Guide (AP Professional) and Mac OS X Developer's Guide (Morgan Kaufmann). He is the author of MinutesMachine, the meeting management software for iPad, as well as Saranac River Trail app for iPhone and iPad. There are more details at champlainarts.com. A native of Washington DC, he has lived in New York City and currently lives in Plattsburgh, NY. He can be reached at northcountryconsulting.com.

Introduction 1
Who Should Read This Book 1
What This Book Covers 1
Downloading the Sample Files 2
How This Book Is Organized 2

PART I: GETTING STARTED WITH OBJECTIVE-C
HOUR 1: Overview of the Developer Program 7
Introducing Objective-C 7
Enrolling as an Apple Developer 8
Choosing Your Program 8
Selecting Your Membership Category 9
Registering for Your Apple ID 10
Setting Up the Development Environment 11
Talking Xcode 11
Introducing the Xcode Workspace 12
Getting Up and Running with Your First Project 16
Summary 17
Q&A 18
Workshop 18
Quiz 18
Quiz Answers 18
Activities 19
HOUR 2: Object-Oriented Programming with Objective-C 21
Object-Oriented Programming in the Objective-C World 21
Implementing Object-Oriented Programming 21
Building Object-Oriented Projects 22
Looking at the Frameworks 23
Creating C with Objects 24
Start Thinking in Objective-C 24
Understanding Data Abstraction 24
Considering Classes and Instances 25
Exploring Encapsulation 25
Using Accessors to Manage Encapsulation 28
Managing Inheritance in the Objective-C World 29
Summary 30
Q&A 31
Workshop 31
Quiz 31
Quiz Answers 31
Activities 31
HOUR 3: Using Object-Oriented Features in Objective-C 33
Communicating to Methods with Messages 33
Looking at a Simple Message 33
Declaring a Method 34
Using Class Methods 35
Working with id-Strongly and Weakly Typed Variables 35
Nesting Messages 36
Looking at Method Signatures and Parameters 36
Allocating and Initializing Objects 37
Summary 39
Q&A 39
Workshop 39
Quiz 39
Quiz Answers 39
Activities 39
HOUR 4: Using Xcode 5 41
Getting to Work with Xcode 41
Keeping Track of Your Source Code 46
Exploring Source Code Control 47
Working in a Source Code Repository World 48
Using Git with Xcode 50
Using a Remote Repository 58
Summary 61
Q&A 61
Workshop 61
Quiz 61
Quiz Answers 61
Activities 62
HOUR 5: Using Compiler Directives 63
Exploring Your Projects 63
Looking at the iOS Project 64
Looking at the OS X Project 64
Looking at Both Projects 65
Working with Compiler Directives 66
Working with Basic Directives 66
Looking at Prefix Headers 67
Looking at Plain C Code in main.m 69
Investigating Header (.h) Files 70
Looking Inside Message (.m) Files 71
Using Objective-C Compiler Directives 74
Summary 74
Q&A 74
Workshop 75
Quiz 75
Quiz Answers 75
Activities 75

PART II: WORKING WITH THE OBJECTIVE-C BASICS
HOUR 6: Exploring Messaging and a Testbed App 77
Setting Up the Testbed Apps 77
Adding a Text Field and Connecting It to Your Code 81
Adding the Text Field 82
Connecting the Text Field to the Code 88
Sending a Message to the Text Field 92
Reviewing the Message Syntax 94
Summary 95
Q&A 95
Workshop 96
Quiz 96
Quiz Answers 96
Activities 96
HOUR 7: Declaring a Class in an Interface File 97
Letting Xcode Do the Work 97
Designing Classes 97
Getting Ready to Create the Class 98
Exploring Class Hierarchies 104
Calling Superclass Methods 104
Introducing Protocols 106
Declaring Classes 106
Writing a Basic Class Declaration 106
Using Forward References 107
Summary 109
Q&A 109
Workshop 109
Quiz 109
Quiz Answers 109
Activities 109
HOUR 8: Declaring Instance Variables in an Interface File 111
Declaring Instance Variables and Properties 111
Using the Class 111
Placing a Class Instance in Context 112
Choosing the Context 113
Creating an Instance Variable for CurrencyConverter with id 114
What Happens When Execution Stops 115
Dynamic Binding 117
Creating an Instance Variable for CurrencyConverter with the Class Name 117
Creating an Instance Variable for CurrencyConverter with a Superclass Name 119
Managing Instance Variable Visibility 123
Summary 124
Q&A 124
Workshop 124
Quiz 124
Quiz Answers 124
Activities 125
HOUR 9: Declaring Properties in an Interface File 127
Comparing Interface Variables and Properties 127
Reviewing Basic Variable Declarations 128
Creating Declared Properties: The Basics 130
Dealing with Memory for Objects 132
Working with Attributes for Declared Properties 133
Using Declared Properties 133
Accessing the Property with Message Syntax 134
Accessing the Property with Dot Syntax 134
Using Attributes 135
Accessor Methods 136
Writability 136
Setter Semantics 137
Atomicity 137
Using Other Attribute Decorators 137
Implementing Properties 138
Creating Accessors with @synthesize 138
Promising Data with @dynamic 139
Summary 139
Q&A 139
Workshop 139
Quiz 139
Quiz Answers 139
Activities 140
HOUR 10: Declaring Methods in an Interface File 141
Working with Methods in a Class 141
Reviewing Method Syntax 142
Distinguishing Between Class and Instance Methods 142
Exploring the Method Declaration 143
Writing the Method Declaration 146
Returning Complex Data Structures from Methods 146
Summary 147
Q&A 147
Workshop 148
Quiz 148
Quiz Answers 148
Activities 148
HOUR 11: Declaring Actions in an Interface File 149
Introducing Actions 149
What Actions Can Do for You 150
Comparing Actions in OS X and iOS 159
Disconnecting Actions 161
Summary 162
Q&A 162
Workshop 163
Quiz 163
Quiz Answers 163
Activities 163
HOUR 12: Routing Messages with Selectors 165
Getting Inside Objective-C Messages 165
Receiver and Selector Objects in Messages 166
Getting Inside the Objective-C Runtime 167
Working with SEL and @selector () 168
Using performSelector 169
Creating a Selector with @selector () 169
Creating a Selector from a String 169
Using a Selector 170
Using NSInvocation 172
Creating an NSInvocation 172
Using NSInvocation Properties 173
Invoking an NSInvocation 175
Testing Whether an Instance Can Respond to a Selector 175
Summary 176
Q&A 176
Workshop 177
Quiz 177
Quiz Answers 177
Activities 177
HOUR 13: Building on the Foundation 179
Exploring the Foundation Framework 179
Foundation Classes 180
Root Classes 180
Other Classes 181
Foundation Paradigms and Policies 182
Mutability 182
Class Clusters 183
Notifications 184
Summary 187
Q&A 187
Workshop 187
Quiz 187
Quiz Answers 187
Activities 187
HOUR 14: Defining a Class in an Implementation File 189
Working with a New Project 189
Reconsidering Dynamic Typing 190
Designing the (Currency) Converter 190
Creating a New App 193
Implementing a Method 197
Expanding the Class with init Methods 200
Summary 202
Q&A 202
Workshop 202
Quiz 202
Quiz Answers 202
Activities 203
HOUR 15: Organizing Data with Collections 205
Collecting Objects 205
Getting Familiar with Property Lists 207
Using Collections in Property Lists 208
Building Collections from Property Lists at Runtime 209
Comparing the Collection Classes 209
Creating a Collection 210
Using the Common Collection Creation Methods 211
Using Objective-C Literal Syntax 212
Reading and Writing Arrays 213
Reading and Writing Dictionaries 213
Creating Sets 214
Enumerating a Collection 214
Examining NSEnumerator Methods 214
Creating NSEnumerator Instances for Collections 215
Testing Membership in a Collection 217
Accessing an Object in a Collection 218
Summary 218
Q&A 218
Workshop 219
Quiz 219
Quiz Answers 219
Activities 219
HOUR 16: Managing Memory and Runtime Objects 221
Managing Objects in Memory 221
Managing Reference Counts Manually 222
Looking at Memory Management Before ARC 223
Summarizing Memory Management 225
Managing Reference Counts with ARC 225
Using Declared Property Attributes 226
Variable Qualifiers 227
Autoreleasing Variables 228
Summary 229
Q&A 229
Workshop 229
Quiz 229
Quiz Answers 229
Activities 229

PART III: EXPANDING AND EXTENDING CLASSES
HOUR 17: Extending a Class with Protocols and Delegates 231
Exploring the Pros and Cons of Subclassing 231
Introducing the Example 232
Working with Protocols 232
Working with Delegates 233
Putting Protocols and Delegates Together 233
Looking Deeper Inside Protocols 236
Summary 236
Q&A 236
Workshop 237
Quiz 237
Quiz Answers 237
Activities 237
HOUR 18: Extending a Class with Categories and Extensions 239
Comparing Categories and Protocols 239
Choosing When to Use a Category 240
Comparing Other Techniques with Categories 240
Comparing Categories with Subclasses 241
Modifying a Class Hierarchy 241
Confining Modifications to Categories 242
Working with Categories 242
Using Class Extensions 245
Working with Informal Protocols 246
Summary 246
Q&A 246
Workshop 247
Quiz 247
Quiz Answers 247
Activities 247
HOUR 19: Using Associative References and Fast Enumeration 249
Catching Up on Objective-C 2.0 Time-Saving Features 249
Extending Classes by Adding Instance Variables (Sort of) 250
Adding an Associative Reference 251
Getting and Setting an Associative Reference 252
Removing an Associative Reference for a Key 254
Removing All Associative References from an Object. 254
Using Fast Enumeration 254
Using Fast Enumeration 254
Using Fast Enumeration with an NSEnumerator 256
Summary 256
Q&A 256
Workshop 257
Quiz 257
Quiz Answers 257
Activities 257
HOUR 20: Working with Blocks 259
Revisiting Blocks 259
Looking at Callbacks 260
Considering Callback Routines 263
Introducing Blocks 264
Creating a Block as a Block Variable 264
Using a Block Variable 265
Exploring Blocks in Cocoa 266
NSString enumerateLinesUsingBlock 267
NSArray enumerateObjectsUsingBlock 268
NSSet enumerateObjectsUsingBlock 268
Looking Deeper into Cocoa Blocks and Memory 269
Summary 269
Q&A 269
Workshop 270
Quiz 270
Quiz Answers 270
Activities 270

PART IV: BEYOND THE BASICS
HOUR 21: Handling Exceptions and Errors 271
Rethinking Exceptions and Errors 271
Introducing the Exception and Error Classes 272
Using Exceptions 273
Using Errors 273
Looking Inside NSException 274
Looking Inside NSError 274
Identifying an Exception 277
Throwing an Exception 278
Catching an Exception 280
Summary 280
Q&A 280
Workshop 280
Quiz 280
Quiz Answers 281
Activities 281
HOUR 22: Grand Central Dispatch: Using Queues and Threading 283
Getting Started with Concurrency 283
Looking at Processors Inside Computers 283
Using Concurrency Without Rewriting User Apps 284
Using Threads for Concurrency 284
Introducing Grand Central Dispatch (GCD) 285
Introducing Queues 286
Dispatch Queues 287
Dispatch Sources 287
Operation Queues 287
Using Dispatch Queues 288
Using Global Concurrent Dispatch Queues 288
Adding a Task to a Global Concurrent Queue 289
Designing with Queues 290
Summary 290
Q&A 290
Workshop 291
Quiz 291
Quiz Answers 291
Activities 291
HOUR 23: Working with the Debugger 293
Logging Information 293
Using Console Logs 294
Using NSLog 295
Enhancing NSLog 295
Using Smart Breakpoints 297
Enhancing Breakpoints with Messages 298
Breaking on a Condition 300
Summary 302
Q&A 302
Workshop 303
Quiz 303
Quiz Answers 303
Activities 303
HOUR 24: Using Xcode Debug Gauges for Analysis 305
Putting Debug Gauges in Perspective 305
Monitoring CPU Utilization 306
Monitoring Memory Utilization 307
Monitoring Energy 308
Using Instruments 310
Summary 311
Q&A 311
Workshop 312
Quiz 312
Quiz Answers 312
Activities 312

PART V: APPENDIXES
Appendix A: C Syntax Summary 313
Data Types 313
Enumerated Type 313
Struct Type 314
Pointers 314
Arrays 315
Control Structures 315
if Statements 315
switch Statements 315
Repeat Statements 316
Appendix B: Apps, Packages, and Bundles 317
Looking Inside a Project Bundle 317
lproj Files 318
Asset Catalogs 318
plist Files 319
Precompiled Header Files (.pch) 319
Appendix C: Archiving and Packaging Apps for Development and Testing 321
Archiving 321

Index 325