15

In many of Android methods, especially constructors and overridden methods, you should or even must call the parent class method using super(). When you use the Eclipse Source > Override/Implement Methods... you get code from a template with TODO tags like this: 

public MyCanvas(Context context, AttributeSet attrs) {
    super(context, attrs);
    // TODO Auto-generated constructor stub
}


@Override
protected void onDraw(Canvas canvas) {
    // TODO Auto-generated method stub      
    super.onDraw(canvas);
}

I do not understand exacly what the superclass does in each case so I always insert my code at the exact location of the //TODO tags. In the example, I would call super() before my code in the constructor and after my code in onDraw().

Can I always rely on these code insertions locations in the generated code? Is there a simple rule/explanation when to call super()?

rgr_mt
  • 985
  • 1
  • 9
  • 16
  • While I think the question is answered - thanks -, I do not like the result. Thinking about API design and separation of responsibilties, I believe an application programmer should not have to look into the source code of an API to find out what is going on. I would like to know if and when to call super() looking at API documention. Maybe an effort should be made to document exactly what each of these methods do in the API class. For example if View.onDraw() does nothing I would rather leave it out for performance reasons, yet I am not shure if I blow something up doing so. – rgr_mt Feb 15 '11 at 03:33
  • 1
    With proper documentation, you should never have to look at the source code to figure out whether (or when) to call super(). Unfortunately, many of the methods in the Android API are poorly documented (or not documented at all). And besides, most of us have learned a long time ago: the only good documentation is the code itself. At least the code is available with Android (unlike some other APIs I won't mention.) – Ted Hopp Feb 15 '11 at 07:00
  • Superclass must be called at FIRST in `onRestoreInstanceState، onStop, onRestart, onStart`, Superclass must be called at LAST in `onDestroy, onPause, onSaveInstanceState, onResume` – Yousha Aleayoub Sep 04 '16 at 15:24

3 Answers3

15

This is a good question. Unfortunately, there is no simple rule for this. You need to know what the superclass implementation does. Sometimes (as in View.onDraw()), the superclass implementation does nothing; calling super() is both harmless and unnecessary. In other cases (such as Activity.onCreate()) the superclass implementation performs critical operations that must be executed at some point in the subclass's processing. Sometimes what happens when you call super() should come before any processing in the subclass, sometimes at other points. Sometimes you want to completely replace the superclass processing with your own, in which case you don't call super() at all. You have complete freedom to call the superclass version at any point (or even at multiple points) in your subclass's logic.

In constructors, the call to a superclass constructor (if present) must be the first thing in the method. If you don't have one, the compiler automatically inserts a call to the no-argument constructor in the superclass. (If the superclass does not have a no-argument constructor, or if it is not accessible to the subclass, the compiler generates an error.)

If the documentation doesn't provide enough information, then you have to look at the source code. The Android code is available here (Gingerbread release). The API code is under core.

EDIT The code is no longer available at git.kernel.org. Here are two other places where you can browse the code:

The main code is in the repository Platform > Frameworks > Base

Ted Hopp
  • 232,168
  • 48
  • 399
  • 521
3

Can I always rely on these code insertions locations in the generated code?

No, sometimes you don't want to call the super.method. Sometimes you want to call it first, sometimes at the last place, etc. It depends. But, I'm talking about methods, no constructors.

Is there a simple rule/explanation when to call super()?

You will always have to all super as the previous answer points. The only case where you don't call super is when the constructor of the super class has no parameters; in that case the compiler will put the super for you.

I do not understand exacly what the superclass does in each case so I always insert my code at the exact location of the //TODO tags

If you are in doubt (I'm talking about super methods), you can always take a look at the source code. Google Code Search is a good resource to do so. Then you can decide whether to put your code before or after the super method; or even, don't put the super method at all.

Keep in mind that not putting the super method is valid at compile time. But, some methods on android won't work unless you invoke the super method (for instance, the onResume method of the Activity class).

Also, sometimes you will decide whether to run the super method or not in runtime. Consider this classic example:

@Override
public boolean onKeyUp(int keyCode, KeyEvent event) {
    if( KeyEvent.KEYCODE_BACK == event.getKeyCode() ){
        return true;
    }
    return super.onKeyUp(keyCode, event);
}

If the user pressed the back key, you won't call the super method. If the user didn't, you delegate the work to the super method.

Cristian
  • 198,401
  • 62
  • 356
  • 264
0

"If a constructor does not explicitly invoke a superclass constructor, the Java compiler automatically inserts a call to the no-argument constructor of the superclass. If the super class does not have a no-argument constructor, you will get a compile-time error. Object does have such a constructor, so if Object is the only superclass, there is no problem."

Check the documentation for non-constructor overrides. Some times you want to call the super, sometimes not.

levis501
  • 4,117
  • 23
  • 25