* <ul>
 * <li> {@link #onCreate} is where you initialize your activity. Most
 * importantly, here you will usually call {@link #setContentView(int)}
 * with a layout resource defining your UI, and using {@link #findViewById}
 * to retrieve the widgets in that UI that you need to interact with
 * programmatically.

 * <li> {@link #onPause} is where you deal with the user leaving your
 * activity. Most importantly, any changes made by the user should at this
 * point be committed (usually to the
 * {@link android.content.ContentProvider} holding the data).
 * </ul>

Because of this, you should use the onPause method to write any persistent data (such as user edits) to storage. In addition, the method onSaveInstanceState(Bundle) is called before placing the activity in such a background state, allowing you to save away any dynamic instance state in your activity into the given Bundle, to be later received in onCreate if the activity needs to be re-created. See the Process Lifecycle section for more information on how the lifecycle of a process is tied to the activities it is hosting. Note that it is important to save persistent data in onPause instead of onSaveInstanceState because the later is not part of the lifecycle callbacks, so will not be called in every situation as described in its documentation.

// 将数据保存到savedInstanceState对象中, 该对象会在重建activity时传递给onCreate方法 
 @Override
 protected void onSaveInstanceState(Bundle savedInstanceState) {
  super.onSaveInstanceState(savedInstanceState);
 }
 
 @Override
 protected void onRestoreInstanceState(Bundle savedInstanceState) {
  super.onRestoreInstanceState(savedInstanceState);
 }

* <p>Do not confuse this method with activity lifecycle callbacks such as
     * {@link #onPause}, which is always called when an activity is being placed
     * in the background or on its way to destruction, or {@link #onStop} which
     * is called before destruction. One example of when {@link #onPause} and
     * {@link #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 {@link #onSaveInstanceState}
     * on B because that particular instance will never be restored, so the
     * system avoids calling it. An example when {@link #onPause} is called and
     * not {@link #onSaveInstanceState} is when activity B is launched in front of activity A:
     * the system may avoid calling {@link #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.