Mac OS X Leopard - ARCAism

496
CHAPTER 26 MAC OS X DEVELOPMENT: OBJECTIVE-C
Protocols
Unlike C++, Objective-C uses a single inheritance model by which a class can inherit only from a
single superclass. To overcome the restrictions posed by single inheritance while adding a different
sort of flexibility, Objective-C classes may inherit additional interface by conforming to any
number of protocols.
A protocol is like a class, except it does not contain variables or provide any implementation.
Rather, it simply defines an interface, which conforming classes are expected to implement.
This same concept was later used in Java but renamed interfaces.
Classes can then comply with a protocol, which tells the compiler they implement any
required methods. For example, some objects can be copied by simply sending them the message
copy. You don’t really care what class the object is; you just care that it implements the appropriate
method. To this end, Foundation defines a protocol, NSCopying. If your BMPerson class
implements the copy method, you can add the protocol to your class declaration:
@interface BMPerson : NSObject
Nothing else in the interface changes, but now you are expected to implement the copy
method.
NOTE Technically when you call - (id)copy, you are calling - (id)copyWithZone:(NSZone
*)zone with a default value for zone. Zone is largely an obsolete concept, but the upshot is that
conforming to NSCopying requires implementing copyWithZone: instead of copy.
You can also define your own protocols. Say you wanted a general interface for providing a
unique ID. You start by defining your protocol, much as you would a class:
@protocol BMIdentifying
- (NSString *)uniqueIDString;
@end
If BMPerson implements uniqueIDString, you can add that to the protocol list:
@interface BMPerson : NSObject
Later in your design, you might want to accept some object but need to make sure it complies
with your BMIdentifying protocol. You can write method signatures that use protocols as
types:
- (void)addIdentifyingObject:(id )object;
To call this method, you can similarly cast to the protocol:
[listOfIdentifyingObjects addIdentifyingObject:(id )object];
Cocoa uses formal and informal protocols for several class-agnostic patterns:
Plug-ins: By creating a plug-in architecture, a programmer can open their application to
third-party development. For such an architecture to work, the programmer must define
an interface. By using protocols, plug-in writers are given total design freedom, as long as
they implement the necessary methods.
Delegates and data sources: To be reusable, an object’s behavior and content must be
configurable. Languages such as Java rely heavily on subclassing to accomplish this.
However, this is often too big a tool for the job. The delegate and data source patterns
leave behavioral and content decisions to another object. By implementing the necessary
methods, programmers can control these classes, without the trouble of subclassing.