Typically, when a developer wants to extend or modify the behavior of a class in an Object Oriented language, inheritance is used.  While Objective-C does support inheritance, it also offers an alternative syntax: "Categories."

The easiest way to conceptualize a category is to think of it as a short cut to add extra methods to an existing class.  This is the key difference between inheritance and categories: inheritance allows you to override methods, add new methods, and add new instance variables / properties; a category is more limited: you cannot create new instance variables / properties... only methods are permitted.

Let's compare and contrast the two with a simple code example.  Let's say I want to add a method to the NSArray class that returns all of the text in an array, as uppercase Strings.  I could try extending NSArray:

   1: @interface StringArrayUpperCaser : NSArray

   2: -(NSString *)stringAtIndexToUpperCase:(NSInteger)index;

   3: @end

   1: #import "StringArrayUpperCaser.h"

   2:  

   3: @implementation StringArrayUpperCaser

   4: -(NSString *)stringAtIndexToUpperCase:(NSInteger)index

   5: {

   6:   NSString *theString = [self objectAtIndex:index];

   7:   return [theString uppercaseString];

   8: }

Unfortunately, I'd find out pretty quickly that I'd need to do a bit more work.  There are certain methods that are required to be overridden in all subclasses of NSArray (not to mention other overrides that would be required to make convenience methods such as "arrayWithObjects" to work properly).

Given that all I wanted to do was add one method to NSArray, this is starting to look like a lot more work than I had bargained for.  So let's try an alternative solution: creating a category.  This process is relatively straight forward.  You'll create an interface and implementation, just as you would with a normal class, however you put the name of your category in parenthesis (to the right of the class name you are enhancing):

   1: @interface NSArray (StringToUpperCase)

   2: -(NSString *)stringAtIndexToUpperCase:(NSInteger)index;

   3: @end

   1: #import "NSArray+StringToUpperCase.h"

   2:  

   3: @implementation NSArray (StringToUpperCase)

   4: -(NSString *)stringAtIndexToUpperCase:(NSInteger)index

   5: {

   6:   NSString *theString = [self objectAtIndex:index];

   7:   return [theString uppercaseString];

   8: }

   9: @end

The convention for naming the physical files is typically <Class Name>+<Category Name>.  In this case, we'd name the files NSArray+StringToUpperCase.h and NSArray+StringToUpperCase.m

Now, when I want to use this new method, I import the category and simply call it on a pointer for an NSArray object:

   1: #import "NSArray+StringToUpperCase.h"

   2:  

   3: int main (int argc, const char * argv[])

   4: {

   5:   @autoreleasepool 

   6:   {

   7:     NSArray *myArray = [NSArray arrayWithObjects:@"this", @"is", @"a", @"test.", nil];

   8:     for( NSInteger i = 0; i < [myArray count]; i++ )

   9:     {

  10:       NSLog(@"%@", [myArray stringAtIndexToUpperCase:i]);

  11:     } 

  12:   }

  13:     return 0;

  14: }

You'll note that although we named our categories in the interface / implementation ("StringToUpperCase"), we did not have to reference the category name when using the new method.  All we had to do was create an NSArray object and send the new message.

If you happen to see the following warning ("... may not respond to..."), double check to make sure you imported the category's header file.

Besides easing sub-classing requirements, Categories can help with organizations: large classes can be separated into different files, based on functionality.  For example, you may have a SystemManager class that does 'read', 'create', and 'manipulate' functionality.  You could have the core methods declared in the SystemManager class, and create categories for each of the separate specific functionalities: SystemManager (read), SystemManager (create), SystemManager (manipulate).  You could also use categories to separate your deprecated methods from the rest of your class: SystemManager (deprecated).

In summary, Categories are a handy way for quickly extending or modifying the behavior of a class, while also offering benefits in terms of logical organization.