Objective-C How to force subclass to implement methods?

Question

Another way of phrasing this question: is it possible for a subclass to be a delegate of its super class? I'm trying to make my code reusable within my app and have a situation where the subsclass needs to implement two methods for it to be functional. How can I ensure this occurs? Or what is the proper way of defining these methods?

Update

I didn't mean to imply that I want the compiler to generate flags. I just want a clean way of organizing my code. Currently I override methods of the superclass. Using that approach the superclass can call [super methodToOverride] and it works. However this doesn't feel very clean to me as there's no way to specify "these are the methods you should override" aside from putting a comment somewhere.

Answer 1

In obj-c, it is not possible to force subclasses to overwrite methods of its superclass. But you can raise an exception in the superclass, should it ever be called because the subclass did not implement a certain method. But a subclass can be a delegate of its superclass, if the superclass does not implement certain methods, and you can enforce that the delegate implements these methods, if the superclass specifies the protocol, i.e. required methods, and the subclass adopts it.

Answer 2

If you want to force your subclass to implement methods from super class, you can do this as below:

//In super class
- (id)someMethod:(SomeObject*)bla
{
     [self doesNotRecognizeSelector:_cmd];
     return nil;
}

Your app will crash if subclass will not implement this method and you don't need to call

[super someMethod:bla];

Answer 3

There is no way to do this in compile time. However you can raise an exception in the base class.

Something like this:

@throw [NSException exceptionWithName:NSInternalInconsistencyException
                               reason:[NSString stringWithFormat:@"You must override %@ in a subclass", NSStringFromSelector(_cmd)]
                             userInfo:nil];

Answer 4

If your question is "how can I get the compiler to flag that a certain class doesn't implement a certain function" then I would say

1. Define a protocol with non-optional methods -- "By default, all methods declared in a protocol are required methods. This means that any class that conforms to the protocol must implement those methods."
2. Define a class ("stub") that declares it implements the protocol
3. Now when a subclass of your stub class is written, the compiler will flag it as an error if the mandatory method(s) aren't implemented

Answer 5

I know that it's awful, but supposed that you need to do this since your 3rdParty SDK requires this design pattern, you could use a Factory pattern:

Supposed then to have the base class MyParentAPIClient and two sub classes like MyFacebookAPIClient and MyGooglePlusAPIClient and that you do something like

self.myAPIClient = [MyParentAPIClient alloc] initWithAPIKey:apiKey];

and that you have defined

@@interface MyParentAPIClient : NSObject {
}

-(void)callAPI;

@end

and you have override this in the two subclasses

@implementation MyFacebookAPIClient
 -(void)callAPI {
    [super callAPI];
    // do something specific for this api client
 }
@end

and

@implementation MyGooglePlusAPIClient
-(void)callAPI {
    [super callAPI];
    // do something specific for this api client
 }
@end

Then you are doing in your controller

[self.myAPIClient callAPI];

but the super class MyParentAPIClient method is being called.

Now you could do a factory in the base class like:

-(void)callAPI {
    if([self isKindOfClass:[MyFacebookAPIClient class]]) {
        [((MyFacebookAPIClient*)self) callAPI];
    } else if([self isKindOfClass:[MyGooglePlusAPIClient class]]) {
       [((MyGooglePlusAPIClient*)self) callAPI];
    }
 }

Of course this have a downside that is to do not call the super in the sub classes that now become:

@implementation MyFacebookAPIClient
 -(void)callAPI {
    // [super callAPI]; the factory method called that
    // do something specific for this api client
 }
@end

and

    @implementation MyGooglePlusAPIClient
    -(void)callAPI {
        // [super callAPI]; being called in the factory
        // do something specific for this api client
     }
    @end

The good news is that there is no change in the methods calls since as soon as you call from the controller:

 [self.myAPIClient callAPI];

You will have the calls

[MyParentAPIClient callAPI]; // parent class
[MyFacebookAPIClient callAPI]; // sub class

The other downside is that the parent class must known the subclass instances.

Now if we take a look at the factory:

if([self isKindOfClass:[MyFacebookAPIClient class]]) {
        [((MyFacebookAPIClient*)self) callAPI];
    } else if([self isKindOfClass:[MyGooglePlusAPIClient class]]) {
       [((MyGooglePlusAPIClient*)self) callAPI];
    }
  }

we could make it better like in several way. Take a look at Dynamic type cast from id to class in objective c and Is there an equivalent to C++'s dynamic cast in Objective-C? or Objective-C dynamic_cast?

Good luck!

Answer 6

The UIGestureRecognizerSubclass.h pattern from UIKit is worth a look, that has all the protected methods that should be overridden and that header is not in the framework include, it is only included in subclasss' .m files. Also, nowadays you can tag methods with NS_REQUIRES_SUPER to require overrides to call super, however it can only be used in interfaces, not protocols so that might influence your design.

For super advanced code, NSAccessibilityProtocols.h in AppKit uses a protocol tag to require subclasses to re-implement methods, even if already implemented by a superclass. Here is an example of that you can paste right into in header in your currently open Xcode project:

NS_PROTOCOL_REQUIRES_EXPLICIT_IMPLEMENTATION
@protocol Protocol
@property (readonly) id theWorstOfTimes;
// -(void)testMethod; // uncomment to test problem
@end

// In this example, ClassA adopts the protocol.
@interface ClassA : NSObject <Protocol>
@property (readonly) id theWorstOfTimes;
@end

@implementation ClassA
- (id)theWorstOfTimes{
    return nil; // default implementation does nothing
}
-(void)testMethod{}
@end

// This class subclasses ClassA (which also adopts 'Protocol').
@interface ClassB : ClassA <Protocol>
@end

@implementation ClassB // expected-warning {{property 'theWorstOfTimes' requires method 'theWorstOfTimes' to be defined - use @synthesize, @dynamic or provide a method implementation in this class implementation}} 
@end

In Xcode you'll see a yellow line at ClassB's expected-warning that the property method is missing. NS_PROTOCOL_REQUIRES_EXPLICIT_IMPLEMENTATION is just a macro for __attribute__((objc_protocol_requires_explicit_implementation)) and this code sample is modified from the test harness of that feature here.

Although this looks great there is a slight problem. Currently this only works for methods that implement protocols, it used to work also for methods but a bug has been introduced in 2014 via a misunderstanding on the purpose of this feature and thus now it is limited to property methods. I have emailed the author to make them aware so hopefully it changed back to its original and proper behavior. To test the bug you can uncomment the method in the protocol and you will see there is no warning in ClassB. Hopefully you can change some of your methods to read-only properties to at least get some use out of it. On the plus side when Xcode offers to "Fix" the issue it does add stubs for the missing methods.

Here is some documentation on NS_PROTOCOL_REQUIRES_EXPLICIT_IMPLEMENTATION: ImplementingAccessibilityforCustomControls nsaccessibilitybutton

If you used this then pat yourself on the back for becoming an ObjC expert if you weren't already!