标签：
代码：
http://pan.baidu.com/s/1kTi0qhD
效果：
eclipse 中这样解释的这些方法
注意除了常规方法外，还有两个方法，onSaveInstanceState(Bundle outState)，onRestoreInstanceState(Bundle savedInstanceState)注意看这两个方法的解释
onCreate(Bundle savedInstanceState)
@Override
Called when the activity is starting. This is where most initialization should go: calling setContentView(int) to inflate the activity‘s UI, using findViewById to programmatically interact with widgets in the UI, calling
managedQuery(android.net.Uri, String [], String, String [], String) to retrieve cursors for data being displayed, etc.
You can call finish from within this function, in which case onDestroy() will be immediately called without any of the rest of the activity lifecycle (onStart, onResume, onPause, etc) executing.
Derived classes must call through to the super class‘s implementation of this method. If they do not, an exception will be thrown.
Overrides: onCreate(...) in Activity
Parameters:
savedInstanceState If the activity is being re-initialized after previously being shut down then this Bundle contains the data it most recently supplied in onSaveInstanceState. Note: Otherwise it is null.
-------------------------------------------------------------------------------------------------------------------------------------------------------------
onSaveInstanceState(Bundle outState)
Called to retrieve per-instance state from an activity before being killed so that the state can be restored in onCreate or onRestoreInstanceState (the Bundle populated by this method will be passed to both).
This method is called before an activity may be killed so that when it comes back some time in the future it can restore its state. For example, if activity B is launched in front of activity A, and at some point activity A is
killed to reclaim resources, activity A will have a chance to save the current state of its user interface via this method so that when the user returns to activity A, the state of the user interface can be restored via onCreate
or onRestoreInstanceState.
Do not confuse this method with activity lifecycle callbacks such as onPause, which is always called when an activity is being placed in the background or on its way to destruction, or onStop which is called before
destruction. One example of when onPause and onStop is called and not this method is when a user navigates back from activity B to activity A: there is no need to call onSaveInstanceState on B because that particular
instance will never be restored, so the system avoids calling it. An example when onPause is called and not onSaveInstanceState is when activity B is launched in front of activity A: the system may avoid calling
onSaveInstanceState on activity A if it isn‘t killed during the lifetime of B since the state of the user interface of A will stay intact.
The default implementation takes care of most of the UI per-instance state for you by calling android.view.View.onSaveInstanceState() on each view in the hierarchy that has an id, and by saving the id of the currently
focused view (all of which is restored by the default implementation of onRestoreInstanceState). If you override this method to save additional information not captured by each individual view, you will likely want to call
through to the default implementation, otherwise be prepared to save all of the state of each view yourself.
If called, this method will occur before onStop. There are no guarantees about whether it will occur before or after onPause.
Parameters:
outState Bundle in which to place your saved state.
See Also:
onCreate
onRestoreInstanceState
onPause
-------------------------------------------------------------------------------------------------------------------------------------------------------------
onRestoreInstanceState(Bundle savedInstanceState)
This method is called after onStart when the activity is being re-initialized from a previously saved state, given here in savedInstanceState. Most implementations will simply use onCreate to restore their state, but it is
sometimes convenient to do it here after all of the initialization has been done or to allow subclasses to decide whether to use your default implementation. The default implementation of this method performs a restore of
any view state that had previously been frozen by onSaveInstanceState.
This method is called between onStart and onPostCreate.
Parameters:
savedInstanceState the data most recently supplied in onSaveInstanceState.
See Also:
onCreate
onPostCreate
onResume
onSaveInstanceState
-------------------------------------------------------------------------------------------------------------------------------------------------------------
setContentView(int layoutResID)
Set the activity content from a layout resource. The resource will be inflated, adding all top-level views to the activity.
Parameters:
layoutResID Resource ID to be inflated.
See Also:
setContentView(android.view.View)
setContentView(android.view.View, android.view.ViewGroup.LayoutParams)
-------------------------------------------------------------------------------------------------------------------------------------------------------------
onStart()
@Override
Called after onCreate — or after onRestart when the activity had been stopped, but is now again being displayed to the user. It will be followed by onResume.
Derived classes must call through to the super class‘s implementation of this method. If they do not, an exception will be thrown.
Overrides: onStart() in Activity
-------------------------------------------------------------------------------------------------------------------------------------------------------------
onResume()
@Override
Called after onRestoreInstanceState, onRestart, or onPause, for your activity to start interacting with the user. This is a good place to begin animations, open exclusive-access devices (such as the camera), etc.
Keep in mind that onResume is not the best indicator that your activity is visible to the user; a system window such as the keyguard may be in front. Use onWindowFocusChanged to know for certain that your activity is
visible to the user (for example, to resume a game).
Derived classes must call through to the super class‘s implementation of this method. If they do not, an exception will be thrown.
Overrides: onResume() in Activity
-------------------------------------------------------------------------------------------------------------------------------------------------------------
onPause()
@Override
Called as part of the activity lifecycle when an activity is going into the background, but has not (yet) been killed. The counterpart to onResume.
When activity B is launched in front of activity A, this callback will be invoked on A. B will not be created until A‘s onPause returns, so be sure to not do anything lengthy here.
This callback is mostly used for saving any persistent state the activity is editing, to present a "edit in place" model to the user and making sure nothing is lost if there are not enough resources to start the new activity
without first killing this one. This is also a good place to do things like stop animations and other things that consume a noticeable amount of CPU in order to make the switch to the next activity as fast as possible, or to
close resources that are exclusive access such as the camera.
In situations where the system needs more memory it may kill paused processes to reclaim resources. Because of this, you should be sure that all of your state is saved by the time you return from this function. In
general onSaveInstanceState is used to save per-instance state in the activity and this method is used to store global persistent data (in content providers, files, etc.)
After receiving this call you will usually receive a following call to onStop (after the next activity has been resumed and displayed), however in some cases there will be a direct call back to onResume without going
through the stopped state.
Derived classes must call through to the super class‘s implementation of this method. If they do not, an exception will be thrown.
Overrides: onPause() in Activity
-------------------------------------------------------------------------------------------------------------------------------------------------------------
onRestart()
@Override
Called after onStop when the current activity is being re-displayed to the user (the user has navigated back to it). It will be followed by onStart and then onResume.
For activities that are using raw Cursor objects (instead of creating them through managedQuery(android.net.Uri, String [], String, String [], String), this is usually the place where the cursor should be requeried (because
you had deactivated it in onStop.
Derived classes must call through to the super class‘s implementation of this method. If they do not, an exception will be thrown.
Overrides: onRestart() in Activity
-------------------------------------------------------------------------------------------------------------------------------------------------------------
onStop()
@Override
Called when you are no longer visible to the user. You will next receive either onRestart, onDestroy, or nothing, depending on later user activity.
Note that this method may never be called, in low memory situations where the system does not have enough memory to keep your activity‘s process running after its onPause method is called.
Derived classes must call through to the super class‘s implementation of this method. If they do not, an exception will be thrown.
Overrides: onStop() in Activity
-------------------------------------------------------------------------------------------------------------------------------------------------------------
onDestroy()
@Override
Perform any final cleanup before an activity is destroyed. This can happen either because the activity is finishing (someone called finish on it, or because the system is temporarily destroying this instance of the activity to
save space. You can distinguish between these two scenarios with the isFinishing method.
Note: do not count on this method being called as a place for saving data! For example, if an activity is editing data in a content provider, those edits should be committed in either onPause or onSaveInstanceState, not
here. This method is usually implemented to free resources like threads that are associated with an activity, so that a destroyed activity does not leave such things around while the rest of its application is still running.
There are situations where the system will simply kill the activity‘s hosting process without calling this method (or any others) in it, so it should not be used to do things that are intended to remain around after the process
goes away.
Derived classes must call through to the super class‘s implementation of this method. If they do not, an exception will be thrown.
Overrides: onDestroy() in Activity
-------------------------------------------------------------------------------------------------------------------------------------------------------------
onPause() onResume() onStop() 何时被调用？
标签：
原文地址：http://www.cnblogs.com/codinging/p/5004892.html
