Table of Contents
Part I: Getting Started with Objective-C
Part II: Working with the Objective-C Basics
Part III: Expanding and Extending Classes
Part I: Getting Started with Objective-C
HOUR 1: Overview of the Developer Program
Enrolling as an Apple Developer
Selecting Your Membership Category
Setting Up the Development Environment
Introducing the Xcode Workspace
Getting Up and Running with Your First Project
HOUR 2: Object-Oriented Programming with Objective-C
Object-Oriented Programming in the Objective-C World
Implementing Object-Oriented Programming
Building Object-Oriented Projects
Understanding Data Abstraction
Considering Classes and Instances
Using Accessors to Manage Encapsulation
Managing Inheritance in the Objective-C World
HOUR 3: Using Object-Oriented Features in Objective-C
Communicating to Methods with Messages
Working with id—Strongly and Weakly Typed Variables
Looking at Method Signatures and Parameters
Allocating and Initializing Objects
Keeping Track of Your Source Code
Working in a Source Code Repository World
HOUR 5: Using Compiler Directives
Working with Compiler Directives
Looking at Plain C Code in main.m
Investigating Header (.h) Files
Looking Inside Message (.m) Files
Using Objective-C Compiler Directives
Part II: Working with the Objective-C Basics
HOUR 6: Exploring Messaging and a Testbed App
Adding a Text Field and Connecting It to Your Code
Connecting the Text Field to the Code
Sending a Message to the Text Field
HOUR 7: Declaring a Class in an Interface File
Getting Ready to Create the Class
Writing a Basic Class Declaration
HOUR 8: Declaring Instance Variables in an Interface File
Declaring Instance Variables and Properties
Placing a Class Instance in Context
Creating an Instance Variable for CurrencyConverter with id
What Happens When Execution Stops
Creating an Instance Variable for CurrencyConverter with the Class Name
Creating an Instance Variable for CurrencyConverter with a Superclass Name
Managing Instance Variable Visibility
HOUR 9: Declaring Properties in an Interface File
Comparing Interface Variables and Properties
Reviewing Basic Variable Declarations
Creating Declared Properties: The Basics
Dealing with Memory for Objects
Working with Attributes for Declared Properties
Accessing the Property with Message Syntax
Accessing the Property with Dot Syntax
Using Other Attribute Decorators
Creating Accessors with @synthesize
HOUR 10: Declaring Methods in an Interface File
Working with Methods in a Class
Distinguishing Between Class and Instance Methods
Exploring the Method Declaration
Writing the Method Declaration
Returning Complex Data Structures from Methods
HOUR 11: Declaring Actions in an Interface File
Comparing Actions in OS X and iOS
HOUR 12: Routing Messages with Selectors
Getting Inside Objective-C Messages
Receiver and Selector Objects in Messages
Getting Inside the Objective-C Runtime
Working with SEL and @selector ()
Creating a Selector with @selector ()
Creating a Selector from a String
Testing Whether an Instance Can Respond to a Selector
HOUR 13: Building on the Foundation
Exploring the Foundation Framework
Foundation Paradigms and Policies
HOUR 14: Defining a Class in an Implementation File
Designing the (Currency) Converter
Expanding the Class with init Methods
HOUR 15: Organizing Data with Collections
Getting Familiar with Property Lists
Using Collections in Property Lists
Building Collections from Property Lists at Runtime
Comparing the Collection Classes
Using the Common Collection Creation Methods
Using Objective-C Literal Syntax
Reading and Writing Dictionaries
Examining NSEnumerator Methods
Creating NSEnumerator Instances for Collections
Testing Membership in a Collection
Accessing an Object in a Collection
HOUR 16: Managing Memory and Runtime Objects
Managing Reference Counts Manually
Looking at Memory Management Before ARC
Managing Reference Counts with ARC
Using Declared Property Attributes
Part III: Expanding and Extending Classes
HOUR 17: Extending a Class with Protocols and Delegates
Exploring the Pros and Cons of Subclassing
Putting Protocols and Delegates Together
Looking Deeper Inside Protocols
HOUR 18: Extending a Class with Categories and Extensions
Comparing Categories and Protocols
Choosing When to Use a Category
Comparing Other Techniques with Categories
Comparing Categories with Subclasses
Confining Modifications to Categories
Working with Informal Protocols
HOUR 19: Using Associative References and Fast Enumeration
Catching Up on Objective-C 2.0 Time-Saving Features
Extending Classes by Adding Instance Variables (Sort of)
Adding an Associative Reference
Getting and Setting an Associative Reference
Removing an Associative Reference for a Key
Removing All Associative References from an Object
Using Fast Enumeration with an NSEnumerator
Creating a Block as a Block Variable
NSString enumerateLinesUsingBlock:
NSArray enumerateObjectsUsingBlock:
NSSet enumerateObjectsUsingBlock:
Looking Deeper into Cocoa Blocks and Memory
HOUR 21: Handling Exceptions and Errors
Rethinking Exceptions and Errors
Introducing the Exception and Error Classes
HOUR 22: Grand Central Dispatch: Using Queues and Threading
Getting Started with Concurrency
Looking at Processors Inside Computers
Using Concurrency Without Rewriting User Apps
Introducing Grand Central Dispatch (GCD)
Using Global Concurrent Dispatch Queues
Adding a Task to a Global Concurrent Queue
HOUR 23: Working with the Debugger
Enhancing Breakpoints with Messages
HOUR 24: Using Xcode Debug Gauges for Analysis
Putting Debug Gauges in Perspective
Appendix B: Apps, Packages, and Bundles
Looking Inside a Project Bundle
Precompiled Header Files (.pch)
Appendix C: Archiving and Packaging Apps for Development and Testing