This means that if you have code in one class that you would like to reuse in another class you can create a subclass. The original class is called the superclass and the subclass gets all the code in the superclass. You can also add additional code to the subclass. Programmers do this all the time which creates a hierarchy like the graphic at the top of this page.
The Super And Self Keywords
If you haven’t yet groked the relationship between classes and objects the details of this can get confusing. For instance, take a look at the init override that you get from Xcode’s code library:
-(id)init{
self = [super init];
if (self) {
//initialize here
}
return self;
}
NOTE I’m assuming you know about how to create classes in Objective-C here. If you don’t know what I’m talking about click here to read the chapter on creating classes in Objective-C.
So I highlighted some particularly confusing keywords that are in theinit function.self andsuper reference objects from the class that we are currently defining.
While both keywords objects created from the class self references the properties and methods defined in the current class definition while super references the properties and methods defined in the superclass definition.
Objects And Classes
Let’s take another look at that init override so we can see the context where we usually see this function.
#import <Foundation/Foundation.h>
@interface MyClass : NSObject
@property(strong) NSString *name;
@end
@implementation MyClass
-(id)init{
self = [super init];
if (self) {
//initialize here
_name = @"MyClass Object";
}
return self;
}
@end
int main(int argc, const char * argv[]){
@autoreleasepool {
MyClass *myObject = [[MyClass alloc] init];
NSLog(@"myObject.name = %@", myObject.name);
}
return 0;
}
Here’s the English version of the code above: we defined a class named MyClass which is a subclass of the NSObject class. MyClass is going to override the init function.
In the main function we are going to instantiate an object named myObject and write out the myObject name value to the console log.
Class Vs Object
A class is a definition of an entity (an abstract model) that is made up of definitions for properties and methods. By itself, a class doesn’t do much other than contain a definition. In the above example all the code that defines the class is between the @interface and @end keywords and the @implementation and @end keywords.
Objects are special variables that are created based on class code definitions. You can see how objects are used in the main function above. Typically, you would create many objects based on one class definition.
How It Gets Confusing
This stuff gets confusing because most people think of classes and objects as the same thing. After all, when you want an object to behave differently you must make changes so rewrite the class definition. So that’s pretty natural. Getting back to the init function though you can see why this gets confusing,
-(id)init{
self = [super init];
if (self) {
//initialize here
}
return self;
}
In that first line of code after the function name, self = [super init];, it looks like we are getting an NSObject object from the superclass, assigning this object to self and then returning this to the caller.
This is not really the case. You are simply getting your MyClass object from the superclass. The reason that it seems like you are getting an NSObject object back here is because you are thinking in terms of objects and not class definitions. Even though this code will be used to initialize and return objects at some point right now we are only working on the code definition.
That self keyword doesn’t represent some NSObject object variable out there. It’s simply a way to reference the code from the superclass definition.
What subclassing really does for you is more like a copy and paste. It’s as if you have copied all of the NSObject code and used this code in MyClass. So that init call to super will just initialize the part of the class definition that is contained in NSObject before you finish up initializing.
