Categories, also known as class extensions, are a unique feature of Objective-C. They allow developers to add new methods to an existing class without modifying its original source code, similar to extension methods in C# or partial classes in other languages.

Key Purposes of Categories

• Adding functionality to framework or third-party classes without subclassing.
• Logically organizing methods of a large class into separate modules.
• Facilitating parallel team development on a single class.

Declaring a Category A category is declared in a header file (.h) using the @interface keyword, followed by the original class name and a new category name in parentheses.

// NSString+Utilities.h
@interface NSString (StringUtilities)
- (NSUInteger)characterFrequency:(unichar)targetChar;
// Adding instance variables is not permitted here.
@end

Explanation:

• NSString is the existing class being extended.
• StringUtilities is the name of the new category.
• characterFrequency: is the new method signature being added. Variable declarations are not allowed within a category interface.

Implementing a Category The implementation is placed in a corresponding .m file (or within the header if desired).

// NSString+Utilities.m
#import "NSString+Utilities.h"

@implementation NSString (StringUtilities)
- (NSUInteger)characterFrequency:(unichar)targetChar {
    NSUInteger count = 0;
    NSUInteger length = [self length];
    for (NSUInteger i = 0; i < length; ++i) {
        if ([self characterAtIndex:i] == targetChar) {
            count++;
        }
    }
    return count;
}
@end

Usage After importing the category header, the new method is available on all instances of the original class.

#import "NSString+Utilities.h"

NSString *sample = @"Hello, World!";
NSUInteger freq = [sample characterFrequency:'o'];
NSLog(@"Frequency: %lu", (unsigned long)freq); // Output: Frequency: 2

Important Considerations

1. Categories can only add methods. Adding instance variables or synthesized properties (@property) is not supported and will cause runtime issues.
2. Methods within a category can access the original class's instance variables.
3. If a category method has the same signature as a method in the original class, the category's implementation takes precedence and the original implementation is overridden.
4. The priority for method calls is: Category methods (latest compiled category first) > Original class methods.

Class Extensions (Anonymous Categories) A class extension is a special, unnamed category (e.g., @interface MyClass()) typically used within a class's own .m file to declare "private" methods and properties that should not be exposed in the public header. Unlike regular categories, methods declared in an extension must be implemented in the main @implementation block.

// MyClass.m
@interface MyClass ()
- (void)privateHelperMethod;
@property (nonatomic, strong) id internalData;
@end

@implementation MyClass
// Implementation of both public and private (extesnion) methods goes here.
- (void)privateHelperMethod {
    // Private implementation
}
@end

This pattern effectively hides the method privateHelperMethod from the public API. Declaring and implementing the extension within the .m file ensures encapsulation, as other files cannot import the .m implementation.