How do you know whether to invoke a superclass method in Objective C

Question

Class Child extends Parent. Parent implements protocol C which has optional methods, including -(void)d. Child has an implementation of -d; should it invoke [super d]?

In other words, what code do I write to invoke [super d] if and only if something will respond to it? Assume that I do not control the implementation of Parent; it may change at any time.

Here are all the ways I have thought of. I am currently using number 4.

Apparently sensible answer 1:

[super d]; // Delete this line if a runtime exception occurs when you try it

This does not work because Parent might implement -d dynamically so this works when you test it and not in the field. Or the implementation of Parent could change so that the result of this test is no longer correct.

Apparently sensible answer 2:

if ([super respondsToSelector:_cmd])
    [super d];

This does not work, because NSObject's implementation of -respondsToSelector will find the implementation in Child and return YES in all cases.

Apparently sensible answer 3:

if ([[self superclass] instancesRespondToSelector:_cmd])
    [super d];

This works if and only if the superclass knows it always implements -d; if instances dynamically determine whether this method is present this technique will not work. Better than 1 in that it will pick up static changes to the implementation of Parent at runtime.

Apparently sensible answer 4:

@try
{
    [super d];
}
@catch (NSException *exception)
{
    NSString *templateReason = [NSString stringWithFormat:
                                @"-[%@ %@]: unrecognized selector sent to instance %p"
                                ,NSStringFromClass([self superclass])
                                ,NSStringFromSelector(_cmd)
                                ,self];
    if (![exception.reason isEqualToString:templateReason])
        @throw exception;
}

Performance of this is poor if the method in the superclass does not exist because computing templateReason and then comparing it to the exception reason is expensive.

This mechanism is fragile because the format of the exception reason string in this case could be altered in a future SDK or runtime release.

score 5 · Accepted Answer · answered Nov 23 '11 at 13:58

5

None of these things are necessary.

If you are subclassing some class or other, you already need to know if you are replacing or supplementing behavior.

In other words, if the implementation exists and you want it done differently, you don't call super.

If the implementation doesn't exist, you don't call super.

If the implementation does exist, but you want to supplement it, you call super.

Addendum:

Wether the implementation can change at any time isn't relevant for your question; what is important is if the interface changes.

If the interface is constantly changing, odds are good the class is an exceptionally poor candidate for subclassing, or even use.

answered Nov 23 '11 at 13:58

Williham Totland

28,471
6
52
68

This answer isn't accurate: assuming the super class implements a protocol that has optional methods, and your subclass implements those optional methods, should you call the super for these optionals? – Moshe Gottlieb Apr 28 '14 at 12:05
@iMoses: You would have to read the documentation for the class in question. – Williham Totland Apr 28 '14 at 15:03
@WillihamTotland - it's not always available. UITableViewController conforms to UIScrollViewDelegate. Does it implement any of it's methods? not on iOS 7 (afaik), but who knows what would happen in iOS 8? Other than that, it's possible to write code that dynamically adds methods or removes them, Objective C is a runtime language and as such, these features are perfectly legal and legit. – Moshe Gottlieb Apr 28 '14 at 16:03
@iMoses: Be that as it may, my answer still covers all the bases. Admittedly, it requires that you know how the class in question operates to begin with, but if you don't know what a class does, why are you subclassing it in the first place? – Williham Totland Apr 29 '14 at 05:57

score 1 · Answer 2 · answered Nov 23 '11 at 13:57

Unfortunately I am not whether any of these answers are good. Unfortunately this comes down to purpose - it may not even be intended for you to call the superclass method, sometimes overriding a method is about replacing the method, not chaining your functionality on top of the superclass's functionality.

It comes down to reading the documentation and choosing the right approach.

If this is about a framework that you are implementing and wish to use a consistent approach, then 2 or 3 should be fine. 1 and 4 rely on exceptions - which are not really intended to be used for anything except truly exceptional issues in objective-c.

Mats Stijlaart · Answer 3 · 2011-11-23T15:08:02.387

-1

In objective c you can define methods in protocols to be required or optional, but your never sure if a class that is conform to a protocol, actually implements that protocol.

So you always have to check if the instance responds to a protocol.
I would choose for option 2, this is the most elegant. When you will make the protocol method optional in the future, this will still be the correct solution.

Option 4 I personally find to much Java-ish.

edited Nov 23 '11 at 15:08

answered Nov 23 '11 at 13:59

Mats Stijlaart

5,058
7
42
58

Calling `[self d]` in `- (void)d` is an exceptionally bad idea, most of the time. – Williham Totland Nov 23 '11 at 14:01
Ow I miss read, it was in the overridden implementation of -d, then you should call [super d]. If it was another instance method of instance A, i meant you should call [self d]. – Mats Stijlaart Nov 23 '11 at 15:07

How do you know whether to invoke a superclass method in Objective C

3 Answers3