Putting methods in separate files

I have a class (MyClass) with a lot of methods. Consequently, the .m file has become quite difficult to read. I'm relatively new to Ob开发者_JAVA百科jective-C (having come from REALbasic) and I was wondering if it's possible to put some of the methods in MyClass into different files and then include them in the class. How would I go about this in Xcode?

Yes it is possible and fortunately this can be done easily in Objective-C with Categories.

Say you have your base class MyClass.

@interface MyClass : NSObject
-(void) methodA;
@end

And the according implementation file (not relevant here).

Then you can create a category by defining a new interface in a new header file:

// the category name is in parenthesis, can be anything but must be unique
@interface MyClass (extended) 
-(void) methodB;
@end

and the implementation file:

@implementation MyClass (extended)
-(void) methodB {

}
@end

Common convention to name these files is ClassToAddMethodsTo+CatgoryName, i.e.:

MyClass+extended.h
MyClass+extended.m

Group related functionality into categories and give it a meaningful name.

In Objective-c you can break a class into 'categories' - a class spread across many files. The normal Object-Oriented way is to use SuperClasses and SubClasses.

This is almost certainly a code smell telling you that you have a design problem. See this antipattern

There is one thing you could do..........
But be warned, some might consider this pure blasphemy. :)

Say you have a class with two methods you want to have in separate files. You'll have three files:

• Class.h
• Class.m
• Class_otherMethod.m

Your Class.h should look just like any other. I think it's better to keep the header file complete, but this 'trick' can work on separating .h files just as well.

@interface Class : NSObject

- (void) method;
- (void) otherMethod;

@end

In your Class.m file you will #include the Class_otherMethod.m inside the Class @implementation like this:

#import "Class.h"

@implementation Class

- (void) method {

    // do something.
}


#include "Class_otherMethod.m"

@end

And your Class_otherMethod.m file will have only the bare otherMethod implementation:

- (void) otherMethod {

    // do something different.
}

Why this works

It's quite simple actually. The preprocessor simply "pastes" the content of Class_otherMethod.m inside the Class.m file and the compiler treats it as one big long file. :P