Android Activity完整的生命周期深入理解

说到activity自身的生命周期

要区分几个概念

1 Activity 官方解释为 “An Activity is an application component that provides a screen with which users can interact in order to do something, such as dial the  phone, take a photo, send an email, or view a map. Each activity is given a window in which to draw its
user interface. ”也就是用户用来交互的每一个窗口，用户当前正在进行的一个操作。

2 back-stack  用户通过触摸程序会通过application launcher来启动一个activity A，启动的activity A会被压入栈顶，如果当前的activity A再启动一个新的activity B，那么此时A调用onStop函数，系统会维护这个activity信息.当用户按下back键的时候，back stack会进行一个pop的操作，并且调用A的onResume()  具体的进出栈细节，以后会详细介绍。

3 Tasks  当用户处于某个activi提: Activity A在名称为"TaskOne应用ty的时候，按下HOME键用户返回到launcher，此时，如果用户再触摸新的应用，则新建一个Task，一个back stack就代表一个task.不同程序的activity可以压入同一个栈中，也就是说可以组成一个task，比如你的程序启动了一个系统自带的发短信的activity，给用户的感觉就是发短信好像是你的程序中的一个功能一样。

注释：以上的行为均为系统的默认设置，有两种方式可以改变activity的行为，加入A启动B，一是在B的manifest设置中，改变行为，另一种是在Activity发起的intent中指定要启动的activity设置，其中Intent的优先级要高于manifest.xml文件,并且有些mode在并不是同时都存在于两种方式中。

android的生命周期包括  onCreate onStart onRestart onResume onPause onStop onDestroy ,activity在声明周期中会调用以上方法来执行不同状态对应的操作，下面介绍各个方法的调用时间

------------------------------------------------------------------------------------------------------------------------------------------------------------

onCreate()     次状态下activity不可被终结

Called when the activity is first created. This is where you should do all of your normal static set up: create views, bind data to lists, etc. This method also provides you with a Bundle containing the activity‘s previously frozen state, if there was one.

Always followed by onStart().

//当activity第一次被创建的时候调用。你应该在这个方法里进行所有的静态创建，创建views，（通过setContnetView方法）向lists绑定数据等等。如果存在保存的状态的话，该方法也提供给你一个包含activity最近状态的一个bundle。onStart方法总是在此方法之后调用

onRestart()    次状态下activity不可被终结

Called after your activity has been stopped, prior to it being started again.

Always followed by onStart()

//在你的activity停止后被调用，在重新开始之前调用

onResume()    次状态下activity不可被终结

Called when the activity will start interacting with the user. At this point your activity is at the top of the activity stack, with user input going to it.

Always followed by onPause().

//当activity将被启动与用户交互的时候被调用。此刻你的activity处于activity栈的顶端，用于用户输入，永远///在onPause之后被调用

onPause()    次状态下activity不可被终结 ，android HoneyComb系统除外

Called when the system is about to start resuming a previous activity. This is typically used to commit unsaved changes to persistent data, stop animations and other things that may be consuming CPU, etc. Implementations of this method must be very quick because
the next activity will not be resumed until this method returns.

Followed by either onResume() if the activity returns back to the front, or onStop() if it becomes invisible to the user.

//当系统即将重新开始以前的activity的时候被调用（不懂，自己的理解是：当当前activity要启动新的activity的时候被调用），典型的应用是用来将还未保存的数据提交到当前的数据，（意思就是保存数据更新），停止animations和其他可能耗费CPU的操作。对此方法的实现必须快速因为下个activity直到此方法返回才会被重新开始。

当activity从back（翻译后台不合适）转到front（与用户交互的状态）的时候，onResume方法会在onPause方法之后被调用

当activity变为不可见的时候，onStop方法会在onPause之后被调用

onStop()     次状态下activity可以被终结

Called when the activity is no longer visible to the user, because another activity has been resumed and is covering this one. This may happen either because a new activity is being started, an existing one is being brought in front of this one, or this one
is being destroyed.

Followed by either onRestart() if this activity is coming back to interact with the user, or onDestroy() if this activity is going away.

//当activity对用户不再可见时被调用，因为另一个activity已经重新开始并且覆盖了当前activity（在栈中）。当有新的activity被启动，或者一个存在的activity重新回到前台状态，又或者当前的activity将被销毁。如果activity要返回前台和用户进行交互则在此方法后调用onReatart方法，如果当前activity要消亡，则onDestroy方法将在此方法后被调用

onDestroy()     次状态下activity可以被终结

The final call you receive before your 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.

这是当你的activity被消亡时接收到的最后一个方法。调用此方法有两种情形：一是 activity将要完成，可通过调用finish方法实现。而是系统销毁activity的实例来释放空间。可以使用isFinish方法来区别两种情形。这个方法常用在onPause方法中，来判断activity是暂停还是将终止。后面的demo将会演示这个功能。

下图是官网的一个生命周期的演示

好了 看一下我写的一个演示的例子吧，

MainFest.xml

view
plain

1. <?xml version="1.0" encoding="utf-8"?>
2. <manifest xmlns:android="http://schemas.android.com/apk/res/android"
3. package="uni.activity"
4. android:versionCode="1"
5. android:versionName="1.0">
6. <uses-sdk android:minSdkVersion="7" />
7. <application android:icon="@drawable/icon" android:label="@string/app_name">
8. <activity android:name=".ActivityDemoActivity"
9. android:label="@string/app_name">
10. <intent-filter>
11. <action android:name="android.intent.action.MAIN" />
12. <category android:name="android.intent.category.LAUNCHER" />
13. </intent-filter>
14. </activity>
15. <activity android:name=".Activity01"
16. android:label="@string/app_name">
17. </activity>
18. </application>
19. </manifest>

布局文件 main.xml

view
plain

1. <?xml version="1.0" encoding="utf-8"?>
2. <LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
3. android:orientation="vertical"
4. android:layout_width="fill_parent"
5. android:layout_height="fill_parent"
6. >
7. <TextView
8. android:layout_width="fill_parent"
9. android:layout_height="wrap_content"
10. android:text="@string/hello"
11. />
12. <Button
13. android:id="@+id/Button_A"
14. android:text="GO to activity 2"
15. android:layout_width="fill_parent"
16. android:layout_height="wrap_content"
17. />
18. </LinearLayout>

activity01.xml

view
plain

1. <?xml version="1.0" encoding="utf-8"?>
2. <LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
3. android:orientation="vertical"
4. android:layout_width="fill_parent"
5. android:layout_height="fill_parent"
6. >
7. <TextView
8. android:layout_width="fill_parent"
9. android:layout_height="wrap_content"
10. android:text="@string/hello"
11. />
12. <Button
13. android:id="@+id/Button_A"
14. android:text="GO to activity 2"
15. android:layout_width="fill_parent"
16. android:layout_height="wrap_content"
17. />
18. </LinearLayout>

String.xml

view
plain

1. <?xml version="1.0" encoding="utf-8"?>
2. <resources>
3. <string name="hello">Hello World, ActivityDemoActivity!</string>
4. <string name="app_name">ActivityDemo</string>
5. <string name="activity01">this is activity 01</string>
6. </resources>

ActivityDemoActivity.java

view
plain

1. /*
2. * @author octobershiner
3. * 2011 07 29
4. * SE.HIT
5. * 演示完整的activity的声明周期，以及isFinish方法的调用
6. * 此activity为程序入口activity
7. * */
8. package uni.activity;
9. import android.app.Activity;
10. import android.content.Intent;
11. import android.os.Bundle;
12. import android.util.Log;
13. import android.view.View;
14. import android.view.View.OnClickListener;
15. import android.widget.Button;
16. public class ActivityDemoActivity extends Activity {
17. /** Called when the activity is first created. */
18. private static final String TAG = "demo";
19. private Button button_A;
20. @Override
21. public void onCreate(Bundle savedInstanceState) {
22. super.onCreate(savedInstanceState);
23. setContentView(R.layout.main);
24. button_A = (Button)this.findViewById(R.id.Button_A);
25. button_A.setOnClickListener(new myButtonListener());
26. }
27. private class myButtonListener implements OnClickListener{
28. @Override
29. public void onClick(View v) {
30. // TODO Auto-generated method stub
31. Intent intent = new Intent();
32. intent.setClass(ActivityDemoActivity.this, Activity01.class);
33. ActivityDemoActivity.this.startActivity(intent);
34. //感兴趣的朋友可以取消下面的代码注释，来测试finish方法的使用，会发现第一个activity会被强制终止
35. //ActivityDemoActivity.this.finish();
36. }
37. };
38. protected void onStart(){
39. super.onStart();
40. Log.i(TAG, "The activityDemo state---->onStart");
41. }
42. protected void onRestart(){
43. super.onRestart();
44. Log.i(TAG, "The activityDemo state---->onReatart");
45. }
46. protected void onResume(){
47. super.onResume();
48. Log.i(TAG, "The activityDemo state---->onResume");
49. }
50. protected void onPause(){
51. super.onPause();
52. //调用isFinishing方法，判断activity是否要销毁
53. Log.i(TAG, "The activityDemo state---->onPause");
54. if(isFinishing()){
55. Log.w(TAG, "The activityDemo will be destroyed!");
56. }else{
57. Log.w(TAG, "The activityDemo is just pausing!");
58. }
59. }
60. protected void onStop(){
61. super.onStop();
62. Log.i(TAG, "The activityDemo state---->onStop");
63. }
64. protected void onDestroy(){
65. super.onDestroy();
66. Log.i(TAG, "The activityDemo state---->onDestroy");
67. }
68. }

Activity01.java

view
plain

1. /*
2. * @author octobershiner
3. * 2011 07 29
4. * SE.HIT
5. * 演示完整的activity的声明周期，以及isFinish方法的调用
6. * 此activity可由ActivityDemoActivity启动
7. * */
8. package uni.activity;
9. import android.app.Activity;
10. import android.os.Bundle;
11. import android.util.Log;
12. public class Activity01 extends Activity{
13. private static final String TAG = "demo";
14. @Override
15. protected void onCreate(Bundle savedInstanceState) {
16. // TODO Auto-generated method stub
17. super.onCreate(savedInstanceState);
18. setContentView(R.layout.activity01);
19. Log.d(TAG, "The activity01 state---->onStart");
20. }
21. protected void onStart(){
22. super.onStart();
23. Log.d(TAG, "The activity01 state---->onStart");
24. }
25. protected void onRestart(){
26. super.onRestart();
27. Log.d(TAG, "The activity01 state---->onReatart");
28. }
29. protected void onResume(){
30. super.onResume();
31. Log.d(TAG, "The activity01 state---->onResume");
32. }
33. protected void onPause(){
34. super.onPause();
35. Log.d(TAG, "The activity01 state---->onPause");
36. //调用isFinishing方法，判断activity是否要销毁
37. if(isFinishing()){
38. Log.w(TAG, "The activity01 will be destroyed!");
39. }else{
40. Log.w(TAG, "The activity01 is just pausing!");
41. }
42. }
43. protected void onStop(){
44. super.onStop();
45. Log.d(TAG, "The activity01 state---->onStop");
46. }
47. protected void onDestroy(){
48. super.onDestroy();
49. Log.d(TAG, "The activity01 state---->onDestroy");
50. }
51. }

下面是演示的结果，

操作过程是：启动ActivityDemoActivity

然后单击按钮进入Activity01

（可见activity先暂停并且不会被释放，实际是个新activity压栈过程，然后新的activity开始，应该是onCreate然后onStart，我打印语句写错了，细心朋友应该看到了，当旧的activity不可见时，调用其onStop方法）

再按返回键回到ActivityDemoActivity

（返回后，处于栈顶的activity01会执行弹栈操作，显示将会被destroy）

再按返回键 回到桌面

其实并不复杂的东邪写的有些长了，但是基本上的显示了activity的完整的生命周期。