Mac OS X Leopard - ARCAism

@implementation BMString
- (NSString *)stringByPrependingString:(NSString *)aString;
{
return [aString stringByAppendingString:self];
}
@end
Now you can do what you want:
BMString *greeting = [BMString stringWithString:@", world!"];
greeting = [greeting stringByPrependingString:@"Hello"];
NSLog(greeting);
*** initialization method -initWithCharactersNoCopy:length:freeWhenDone: cannot
be sent to an abstract object of class BMString: Create a concrete instance!
Or perhaps not. It turns out there’s a lot more to subclassing NSString than meets the eye.
For one thing, inheritance is not perfect. Private members, for example, are not inherited. Furthermore,
NSString is not an actual class, but rather, it’s simply the interface to a class cluster, an
implementation detail you’ve been protected from until now.
The NSString documentation provides instructions on subclassing NSString. We’ll sum it up
for you: it’s a lot of work for just adding a simple method. Even if you managed to do all that
work, you’d still have to constantly remember to use your custom subclass instead of the standard
NSString.
Objective-C Dynamic Runtime to the rescue! Since classes, method signatures, and method
implementations are all addressable data, you should be able to create a new method and add it
to the NSString class. In fact, this operation is so common, Objective-C gives you a convenient
shortcut for doing so: categories.
Categories are additional methods defined on an existing class. As an organizational tool,
they let you arrange your code in a way that best fits your needs, and not the needs of the
machine. For example, a very large class can be broken into several files, with a separate header
for different areas of functionality.
Conversely, functionality can be added to several classes at once. For example, a new feature
that affects multiple classes could be implemented in a single file, leaving the original class files
untouched. Anyone wanting to use the new features needs to import only the new header, while
older classes can simply ignore it.
NOTE Categories are a lot like protocols, except they add implementation in addition to
interface. As noted, before Leopard introduced optional protocol methods, informal protocols
were implemented as categories.
Categories are useful for far more than organization. Categories can be defined on any class,
including classes that you did not write and that have already been compiled. That means, if you
want to add functionality to a class such as NSString, there’s no need to hassle with trying to subclass
it. You can simply add the functionality to NSString itself. We declare a category using
parentheses after the base class name:
#import
CHAPTER 26 MAC OS X DEVELOPMENT: OBJECTIVE-C 499
@interface NSString (BMString)
- (NSString *)stringByPrependingString:(NSString *)aString;
@end