book

Objective-C

Name: Objective-C
Author: Jiva DeVoe
ISBN: 9780470479223

by Jiva DeVoe

February 2011

Intermediate to advanced

400 pages

8h 15m

English

Wiley

Read now

Unlock full access

Copyright
About the Author
Credits
Preface
Acknowledgments
I. Introducing Objective-C
1. Introducing Objective-C
1.1. Using Xcode for Development1.1.1. Starting a project1.1.2. Exploring the files in your project1.1.3. Adding source files1.1.4. The main Xcode window1.2. Understanding the Compilation Process1.2.1. Writing code1.2.2. Turning source code into compiled code and compiled code into an executable1.2.3. Exploring application bundles1.2.4. Working with build settings1.3. Using the Xcode Static Analyzer1.4. Understanding the Objective-C Runtime1.5. Summary
2. Understanding Basic Syntax
2.1. Working with Statements and Expressions2.1.1. Declaring variables2.1.2. Using comments2.1.3. Exploring scalar types2.1.4. Using special variable modifiers2.1.5. Understanding structures2.1.6. Using typedefs2.1.7. Using enum2.1.8. Understanding pointers2.1.9. Using operators2.1.10. The ternary operator2.2. Working with Functions2.2.1. Understanding functions2.2.2. Defining functions2.2.3. Understanding implementation versus interface2.2.4. Linking with implementation files2.3. Controlling Program Flow2.3.1. Using conditional statements2.3.1.1. Using if-else2.3.1.2. Using the ternary conditional2.3.1.3. Using switch statements2.3.1.4. Choosing among conditional statements2.3.2. Working with loops2.3.2.1. Working with for2.3.2.2. Traditional for loops2.3.2.3. Using for for fast enumeration2.3.2.4. Working with while2.3.2.5. Using do2.4. Applying What You Have Learned2.5. Summary
3. Adding Objects
3.1. Understanding Objects3.1.1.3.1.1.1. Understanding inheritance3.1.1.2. Using polymorphism3.1.1.3. Using the id datatype3.1.2. Creating classes3.1.2.1. Working with class files3.1.2.2. Writing object methods3.1.2.3. Working with the special object methods3.1.2.4. Writing class methods3.1.3. Declaring objects3.1.4. Making calls on objects3.2. Working with Properties3.2.1. Understanding the differences between state and behavior3.2.1.1. Using properties to declare object state3.2.1.2. Understanding synthesized property accessors3.2.1.3. Using the nonatomic attribute3.2.1.4. Using the assign, retain, and copy Attributes3.2.1.5. Using properties with different data member names3.2.2. Using dot notation3.3. Applying Objects3.3.1. Creating the employee class3.3.2. Creating the manager class3.3.3. Tying the classes together in the HR main
4. Understanding Objective-C Memory Management
4.1. Using Reference Counting4.1.1. Learning the memory management rules4.1.2. Using autorelease4.1.2.1. Understanding autorelease pools4.1.3. Understanding memory from inside the object4.1.3.1. Writing initializers4.1.3.2. Writing dealloc Methods4.2. Using Garbage Collection4.2.1. Understanding the Garbage Collector4.2.1.1. Understanding reference types4.2.2. Configuring your project for garbage collection4.2.3. Using Frameworks in a Garbage Collected Project4.3. Exploring Key Garbage Collector Patterns4.3.1. Managing finite resources4.3.2. Writing foundation applications with garbage collection4.3.3. Working with objects in nib files4.3.4. Forcing garbage collection4.3.5. Working with void pointers and garbage collection4.3.6. Using the object oriented interface to the garbage collector4.4. Understanding What Memory Management Model to Use for Your Projects4.5. Summary

II. Exploring Deeper Features
5. Working with Blocks
5.1. Understanding Blocks5.1.1. Declaring code blocks5.1.2. Using code blocks5.2. Understanding Important Block Scoping5.2.1. Managing code block memory5.2.2. Making blocks easier to read with typedef5.3. Using Blocks with Threads5.3.1. Working with Grand Central Dispatch5.3.2. Using GCD functions to dispatch code blocks in threads5.4. Working with Common Block Design Patterns5.4.1. Using code blocks for maps5.4.2. Using Blocks in the Standard API5.5. Applying Blocks to an Embarrassingly Parallel Task5.5.1. Creating the project5.5.2. Using blocks with an array to filter for primes5.5.3. Using Grand Central Dispatch5.6. Summary
6. Using Key Value Coding and Key Value Observing
6.1. Accessing Object Properties Using Key Value Coding6.1.1. Working with key paths6.1.2. Writing KVC compliant accessors6.1.3. Using KVC with arrays6.1.3.1. Using indexed accessors6.1.3.2. Using Unordered Accessors6.1.4. Using KVC with structures and scalars6.1.5. Searching objects for attributes6.2. Observing Changes to KVC-Compliant Values6.2.1. Using KVO6.2.2. Registering as an observer6.2.3. Defining callbacks for KVO6.2.4. Removing an observer6.2.5. Implementing manual notifications6.2.6. Understanding risks with KVO6.3. Applying Key Value Observing6.4. Summary
7. Working with Protocols
7.1. Favoring Composition Over Inheritance7.1.1. Understanding why you don't need (or want) multiple inheritance7.1.2. Understanding how protocols solve the problem7.1.3. Documenting an expected interface for others to implement7.2. Implementing Protocols in Your Objects7.2.1. Declaring a protocol7.2.2. Declaring that a class implements a protocol7.2.3. Declaring an object that must implement a protocol7.2.4. Exploring formal and informal protocols7.2.5. Determining if an object implements optional methods7.2.6. Avoiding Circular Protocol Dependencies7.3. Exploring examples of protocol use7.4. Summary
8. Extending Existing Class Capabilities
8.1. Working with Third-Party Frameworks and Classes8.2. Working with Categories8.2.1. Declaring categories8.2.2. Implementing category methods8.2.3. Declaring categories in header files8.2.4. Using a category8.2.5. Breaking up functionality using categories8.2.6. Extending class methods8.2.7. Exploring category limitations8.2.8. Implementing protocols with categories8.2.9. Understanding the dangers of creating categories on NSObject8.3. Extending Classes using Anonymous Categories8.4. Associating Variables with Existing Classes8.5. Summary
9. Writing Macros
9.1. Reviewing the Compilation Process9.1.1. Understanding how macros work9.2. Defining Macros9.2.1. Defining constants9.2.2. Passing constants by compilation9.2.3. Using variables in macros9.2.4. Using stringification9.2.5. Handling conditional switching9.2.6. Using built-in macros9.3. Summary
10. Handling Errors
10.1. Classifying Errors10.1.1. Understanding how to interrupt program flow10.2. Using the Different Mechanisms for Error Handling10.2.1. Using return codes10.2.2. Using exceptions10.2.3. Using NSError10.2.3.1. Creating an NSError Object10.2.3.2. Understanding the NSError userInfo Dictionary10.2.3.3. Working with a recovery attempter10.2.3.4. Working with NSErrors in methods10.3. Summary
III. Using the Foundation Framework
11. Understanding How the Frameworks Fit Together
11.1. Understanding the Foundation Framework11.1.1. Exploring other frameworks11.2. Using Frameworks in Your Projects11.2.1. Adding frameworks11.2.2. Including the headers11.2.3. Considering garbage collection11.3. Summary
12. Using Strings
12.1. Understanding the String Declaration Syntax12.1.1. Using format strings12.1.2. Working with Other NSString Methods12.1.3. Using NSString categories12.2. Summary
13. Working with Collections
13.1. Working with Arrays13.1.1. Using dictionaries13.1.2. Working with sets13.1.3. Understanding mutability13.2. Understanding Collections and Memory Management13.2.1. Using specialized collections13.3. Enumerating13.4. Sending Messages to Elements13.5. Sorting and Filtering13.6. Using Blocks with Collections13.7. Summary
14. Using NSValue, NSNumber, and NSData
14.1. Using NSValue and NSNumber14.1.1. Wrapping arbitrary datatypes with NSValue14.1.2. Wrapping numbers with NSNumber14.1.3. Doing arithmetic with NSDecimalNumber14.2. Using NSData and NSMutableData14.2.1. Creating NSData objects14.2.2. Accessing the raw bytes in an NSData object14.3. Summary
15. Working with Times and Dates
15.1. Constructing Dates15.1.1. Constructing Dates15.1.2. Working with Time Intervals15.1.3. Comparing dates15.1.4. Using NSCalendar15.1.5. Working with time zones15.2. Using NSDateFormatter15.3. Summary
IV. Exploring Advanced Topics
16. Multiprocessing with Threads
16.1. Synchronizing Code16.1.1. Using Locks16.1.2. Using the @synchronize keyword16.1.3. Understanding atomicity16.2. Using NSThread16.2.1. Creating threads16.2.2. Manipulating Running Threads16.2.3. Accessing the main thread16.2.4. Crossing threads using perform selector16.3. Using NSOperation and NSOperationQueue16.3.1. Creating operations16.3.2. Adding operations to queues16.3.3. Manipulating queue parameters16.3.4. Using other kinds of operations16.4. Summary
17. Objective-C Design Patterns
17.1. Recognizing Patterns in Solutions17.2. Describing Design Patterns in Objective-C17.2.1. Using Singletons17.2.1.1. Problem17.2.1.2. Solution17.2.1.3. Discussion17.2.2. Delegating responsibility17.2.2.1. Problem17.2.2.2. Solution17.2.2.3. Discussion17.2.3. Notifying objects of changes17.2.3.1. Problem17.2.3.2. Solution17.2.3.3. Discussion17.3. Summary
18. Reading and Writing Data with NSCoder
18.1. Implementing the NSCoding Protocol in Your Objects18.1.1. Implementing the NSCoding Protocol in Your Objects18.1.2. Encoding objects18.1.3. Encoding basic types18.1.4. Working with object graphs18.1.5. Using other types of data18.1.6. Decoding objects18.2. Using NSArchiver and NSUnarchiver18.3. Working with Archiver File Formats and Legacy Data18.4. Summary
19. Using Objective-C on Other Platforms
19.1. Using GNUstep19.1.1. Using Cocotron19.1.2. Using other open source libraries19.2. Looking Toward the Future19.3. Summary

Content preview from Objective-C

Chapter 7. Working with Protocols

In This Chapter

Solving object-oriented design problems with protocols
Implementing protocols for your classes
Adopting protocols
Working with optional methods
Understanding formal versus informal protocols

Objective-C does not feature multiple inheritance, which has advantages as well as disadvantages. It is advantageous because multiple inheritance results in complicated issues that can be difficult to resolve. However, it is also a disadvantage because there are times when you want to have a class, which implements a specific interface without necessarily inheriting from the class that specifies that interface. Thankfully, the designers of Objective-C included a feature to address exactly this situation, protocols.

Essentially, a protocol defines an interface that can be implemented by multiple other classes without the use of inheritance. This enables you to mix and match functionality on a given class so that the class can be adapted to different uses.

Favoring Composition Over Inheritance

An object oriented design axiom known as "favor composition over inheritance" means that rather than always turning to inheritance as a tool for extending functionality of a given class, you should instead first try to solve the problem by using other classes compositionally within your class. For example, if you needed to implement a class that provided an interface between a network service and your application, instead of inheriting from a socket class (a class ...

Become an O’Reilly member and get unlimited access to this title plus top books and audiobooks from O’Reilly and nearly 200 top publishers, thousands of courses curated by job role, 150+ live events each month,
and much more.

Read now

Unlock full access

More than 5,000 organizations count on O’Reilly

O’Reilly covers everything we've got, with content to help us build a world-class technology community, upgrade the capabilities and competencies of our teams, and improve overall team performance as well as their engagement.

Julian F.

Head of Cybersecurity

I wanted to learn C and C++, but it didn't click for me until I picked up an O'Reilly book. When I went on the O’Reilly platform, I was astonished to find all the books there, plus live events and sandboxes so you could play around with the technology.

Addison B.

Field Engineer

I’ve been on the O’Reilly platform for more than eight years. I use a couple of learning platforms, but I'm on O'Reilly more than anybody else. When you're there, you start learning. I'm never disappointed.

Amir M.

Data Platform Tech Lead

I'm always learning. So when I got on to O'Reilly, I was like a kid in a candy store. There are playlists. There are answers. There's on-demand training. It's worth its weight in gold, in terms of what it allows me to do.

Mark W.

Embedded Software Engineer

Publisher Resources

ISBN: 9780470479223Purchase book

Cloud Computing

Data Engineering

Data Science

AI & ML

Programming Languages

Software Architecture

IT/Ops

Security

Design

Business

Soft Skills

Objective-C

by Jiva DeVoe

Chapter 7. Working with Protocols

Favoring Composition Over Inheritance

Become an O’Reilly member and get unlimited access to this title plus top books and audiobooks from O’Reilly and nearly 200 top publishers, thousands of courses curated by job role, 150+ live events each month,
and much more.