Title: An Introduction to Objective-C

There is little language support for informal protocols, but in the Foundation framework, informal protocols are often declared as a category of the root class, NSObject. Here is the list of methods in GNUStep's version of Foundation for the informal protocol NSKeyValueCoding, which defines a mechanism in which the properties of an object are accessed indirectly by name (or key), rather than directly through invocation of an accessor method or as instance variables:

@interface NSObject (NSKeyValueCoding)
+ (BOOL) accessInstanceVariablesDirectly;
+ (BOOL) useStoredAccessor;
- (id) handleQueryWithUnboundKey: (NSString*)aKey;
- (void) handleTakeValue: (id)anObject
                    forUnboundKey: (NSString*)aKey;
- (id) storedValueForKey: (NSString*)aKey;
- (void) takeStoredValue: (id)anObject forKey:
                    (NSString*)aKey;
- (void) takeStoredValuesFromDictionary:
                    (NSDictionary*)aDictionary;
- (void) takeValue: (id)anObject forKey:
                    (NSString*)aKey;
- (void) takeValue: (id)anObject forKeyPath:
                    (NSString*)aKey;
- (void) takeValuesFromDictionary:
                    (NSDictionary*)aDictionary;
- (void) unableToSetNilForKey: (NSString*)aKey;
- (id) valueForKey: (NSString*)aKey;
- (id) valueForKeyPath: (NSString*)aKey;
- (NSDictionary*) valuesForKeys: (NSArray*)keys;
@end

Any object that derives from NSObject can select from this list which methods it needs to implement in order to acquire appropriate key-value coding functionality.

Formal protocols are enforced by the language. They are declared as in the following pseudocode:

@protocol ProtocolName
method declarations
@end

Here is a declaration for the NSCoding protocol for the serialisation ('flattening') and deserialisation (reconstruction) of objects associated with archiving from disk or some other form of distribution to another address space.

@protocol NSCoding - (void) encodeWithCoder: (NSCoder*)aCoder; - (id) initWithCoder: (NSCoder*)aDecoder; @end

If the class Person needed to be stored on disk, it would adopt the NSCoding protocol:

#import <Foundation/Foundation.h>
@interface Person : NSObject <NSCoding>
{
  NSString *name;
  NSString *address;
}
// Accessor methods
- (NSString *)name;
- (NSString *)address;
- (void)setName:(NSString *)aName;
- (void)setAddress:(NSString *)anAdress;
// Other methods ...
@end

@implementation Person
// Accessor methods
- (NSString *)name {return name;}
- (NSString *)address {return address;}
- (void)setName:(NSString *)aName
{
  [aName retain];
  [name release];
  name = aName;
}
- (void)setAddress:(NSString *)anAdress
{
  [anAddress retain];
  [address release];
  address = anAdress;
}
// NSCoding methods
- (void) encodeWithCoder: (NSCoder*)aCoder
{
  [super encodeWithCoder:coder];
  [aCoder encodeObject:name];
  [aCoder encodeObject:address];
}
- (id) initWithCoder: (NSCoder*)aDecoder;
{
  self = [super initWithCoder:coder];
  name = [[coder decodeObject] retain];
  address = [[coder decodeObject] retain];
  return self;
}
// Called when the object is deallocated
- (void) dealloc {[name release]; [address release]}
@end

Formal protocols are equivalent to interfaces in Java; indeed, the designers of Java have copied this idea from Objective-C. Assuming that Foundation had been implemented in C++ you would write something like the following abstract class definition:

class NSObject;
class NSCoding {
  virtual void encodeWithCoder(NSCoder& aCoder) = 0;
  virtual NSObject* decodeWithCoder(
                         const NSCoder& aCoder) = 0;
};

class Person : public NSObject, public NSCoding {
  NSString *name_, *address_;
public:
  // Accessor functions
  NSString* name();
  void setName(const NSString* aName);
  NSString* address();
  void setAddress(const NSString* anAddress);
  // NSCoder virtual functions
  void encodeWithCoder(NSCoder& aCoder);
  NSObject* decodeWithCoder(const NSCoder& aCoder);
  // Other functions ...
  // Called when the object is deallocated
  virtual ~Person();
};

The implemention of these methods in C++ is left to the reader's imagination.

Unlike C++, neither Objective-C nor Java implements multiple inheritance, and so these languages need a separate mechanism for adopting protocols.

It cannot always be known at run-time whether a particular object implements a formal protocol; it can be tested in the following way:

if([anObject conformsTo:@protocol(NSCoding)])
   [anObject encodeWithCoder:myCoder];