super.onCreate(savedInstanceState);

Question

I have created an Android Application Project and in MainActivity.java > onCreate() it is calling super.onCreate(savedInstanceState).

As a beginner, can anyone explain what is the purpose of the above line?

Stinkhorn

Answer 1

Every Activity you make is started through a sequence of method calls. onCreate() is the first of these calls.

Each and every one of your Activities extends android.app.Activity either directly or by subclassing another subclass of Activity.

In Java, when you inherit from a class, you can override its methods to run your own code in them. A very common example of this is the overriding of the toString() method when extending java.lang.Object.

When we override a method, we have the option of completely replacing the method in our class, or of extending the existing parent class' method. By calling super.onCreate(savedInstanceState);, you tell the Dalvik VM to run your code in addition to the existing code in the onCreate() of the parent class. If you leave out this line, then only your code is run. The existing code is ignored completely.

However, you must include this super call in your method, because if you don't then the onCreate() code in Activity is never run, and your app will run into all sorts of problem like having no Context assigned to the Activity (though you'll hit a SuperNotCalledException before you have a chance to figure out that you have no context).

In short, Android's own classes can be incredibly complex. The code in the framework classes handles stuff like UI drawing, house cleaning and maintaining the Activity and application lifecycles. super calls allow developers to run this complex code behind the scenes, while still providing a good level of abstraction for our own apps.

Piperine

one more question - when we override the parent class method then does this derived method still hold the code of parent class method, or it is a new fresh method? – Stinkhorn

If you call super, the code of the parent method is put where the super call is. If super is not called, it is a fresh method. – Piperine

Raghav Sood, I think you should add your comment text to the answer since it explains the usage of super method more understandably for beginners. At least I understood it only from your comment :) – Sousaphone

That was very detailed and really helpful. In 2021, I find it still helpful. – Ovum

Answer 2

*Derived class onCreate(bundle) method must call superclass implementation of this method. It will throw an exception SuperNotCalledException if the "super" keyword is not used.

For inheritance in Java, to override the superclass method and also to execute the above class method, use super.methodname() in the overriding derived class method;

Android class works in the same way. By extending the Activity class which have onCreate(Bundle bundle) method in which meaningful code is written and to execute that code in the defined activity, use the super keyword with the method onCreate() like super.onCreate(bundle).

This is a code written in Activity class onCreate() method and Android Dev team might add some more meaningful code to this method later. So, in order to reflect the additions, you are supposed to call the super.onCreate() in your Activity class.

protected void  onCreate(Bundle savedInstanceState) {
    mVisibleFromClient = mWindow.getWindowStyle().getBoolean(
    com.android.internal.R.styleable.Window_windowNoDisplay, true);
    mCalled = true;
}

boolean mVisibleFromClient = true;

/**
 * Controls whether this activity main window is visible.  This is intended
 * only for the special case of an activity that is not going to show a
 * UI itself, but can't just finish prior to onResume() because it needs
 * to wait for a service binding or such.  Setting this to false prevents the UI from being shown during that time.
 * 
 * <p>The default value for this is taken from the
 * {@link android.R.attr#windowNoDisplay} attribute of the activity's theme.
 */

It also maintains the variable mCalled which means you have called the super.onCreate(savedBundleInstance) in your Activity.

final void performStart() {
    mCalled = false;
    mInstrumentation.callActivityOnStart(this);
    if (!mCalled) {
        throw new SuperNotCalledException(
            "Activity " + mComponent.toShortString() +
            " did not call through to super.onStart()");
    }
}

See source code here.

http://grepcode.com/file/repository.grepcode.com/java/ext/com.google.android/android/1.5_r4/android/app/Activity.java#Activity.onCreate%28android.os.Bundle%29

Dewclaw

Answer 3

Because upon super.onCreate() it will reach the Activity (parent class of any activity) class to load the savedInstanceState,and we normaly don't set any saved instance state, but android framework made such a way that, we should be calling that.

Probative

Your code will compile happily even if you don't call super.onCreate(savedInstanceState), unless you have some other error in it – Piperine

Answer 4

It is information you want returned to your application, via onCreate(), if the activity is destroyed and restarted due to some implicit reason (e.g., not because the user pressed the back button). The most common use of onSaveInstanceState() is to handle screen rotations, as by default, activities are destroyed and recreated when the user slides out the G1 keyboard.

The reason to call super.onCreate(savedInstanceState) is because your code will not compile otherwise. ;-)

Ledesma