Mac OS X Leopard - ARCAism

492
CHAPTER 26 MAC OS X DEVELOPMENT: OBJECTIVE-C
The only difference, of course, is that the factory method produces an autoreleased instance,
whereas the manually allocated method does not.
NOTE Why bother with factory methods? There are some edge cases where they are useful.
Singleton optimizations are one. Teaching people how to write class methods is another.
Mostly, though, it’s just a way to save three lines of code. For something you aren’t using
much, it isn’t worth the hassle, but if it’s something you use a lot, the savings add up. The foundation
classes, such as NSString and NSArray, are lousy with factory methods. If you multiply
three lines of code by the number of times you instantiate NSArray, we’re talking thousands of
lines of code. That is why it’s commonly said that Objective-C programmers hate code.
Init and Dealloc
With the class methods implemented, it’s time to fill out the instance methods. The first method
declaration you come to looks unfamiliar:
- (id)init;
A quick visit to the interface reveals no such declaration. Veterans of object-oriented programming
are sagely nodding right about now. The init method was inherited from the
superclass, NSObject.
TIP In Xcode, you can switch between a class’s interface and its implementation with the keystroke
Cmd+up arrow.
During the instantiation of an object, you actually call two methods. The first, alloc, is sent
to the class you want to instantiate. This returns an object—you hope an instance of the class
you just called. However, the object is in a dangerous state. Its instance variables have been
declared, but any pointers are not actually pointing to anything. Dereferencing or messaging a
floating pointer will cause any program to immediately crash. As such, you immediately call the
new object’s instance method, init.
If a superclass implements a method, you can call the method on any subclass, and the
superclass’s implementation will be found and executed. However, if that subclass also
implements the method, the subclass’s implementation will be used instead. In object-oriented
programming, you say that the subclass’s implementation overrides the superclass’s implementation.
Sometimes that’s what you want, but sometimes you just want to add something to the
superclass’s method, rather than replacing it outright. To accomplish this, you call the superclass’s
implementation from within your own. You do this by sending a message to the superclass
via the keyword super.
In Objective-C, as with any language, there are implied contracts. For example, nothing in
the language is going to force you to call init right after alloc. You just have to do it to make
things work right. Another implied contract is that if you override init, you have to call super,
and if that call fails for some reason, you have to return nil. Since nil is equal to the Boolean NO,
we can do so with a simple if statement.
if (![super init])
return nil;
Only then are you safe to do your own initialization, setting your name pointer safely to nil:
name = nil;