Android生命周期详解

转载来自：http://104zz.iteye.com/blog/1685753

首先看一下Android api中所提供的Activity生命周期图:

 

第一：一个Activity正常的生命周期冲启动到销毁过程如下：onCreate()->onStart()->onResume()->onPause->onStop()->onDestroy();

代码如下：

 

Java代码  

1. import android.app.Activity;  
2. import android.content.Intent;  
3. import android.os.Bundle;  
4. import android.util.Log;  
5. import android.view.View;  
6. import android.view.View.OnClickListener;  
7. import android.widget.Button;  
8.   
9. public class MainActivity extends Activity implements OnClickListener{  
10.   
11.       
12.     private String TAG ="Activity1";  
13.     private Button btn1,btn2,btn3;  
14.       
15.     //在完成生命周期开始时调用  
16.     @Override  
17.     public void onCreate(Bundle savedInstanceState) {         
18.         super.onCreate(savedInstanceState);  
19.         //初始化一个活动  
20.         Log.e(TAG, "onCreate()");  
21.         setContentView(R.layout.activity_main);  
22.         btn1 = (Button) this.findViewById(R.id.btn1);  
23.         btn2 = (Button) this.findViewById(R.id.btn2);   
24.         btn3 = (Button) this.findViewById(R.id.btn3);   
25.         btn1.setOnClickListener(this);  
26.         btn2.setOnClickListener(this);  
27.         btn3.setOnClickListener(this);  
28.     }  
29.       
30.     //在onCreate方法完成后调用，用于恢复UI状态  
31.     @Override  
32.     protected void onRestoreInstanceState(Bundle savedInstanceState) {  
33.         super.onRestoreInstanceState(savedInstanceState);  
34.         //从savedInstanceState恢复UI状态  
35.         //这个Bundle也被传递给了onCreate  
36.     }  
37.   
38.    //在可见生存期的开始时调用  
39.     @Override  
40.     protected void onStart() {  
41.          Log.e(TAG, "onStart()");  
42.         super.onStart();  
43.         //既然活动可见，就应用任何要求的UI活动  
44.     }  
45.       
46.      //在随后的活动进程可见生命周期之前调用  
47.     @Override  
48.     protected void onRestart() {  
49.          Log.e(TAG, "onRestart()");  
50.         super.onRestart();  
51.         //加载活动可见，知道活动在此进程中已经可见  
52.     }  
53.     //在活动状态生存期开始调用  
54.     @Override  
55.     protected void onResume() {  
56.         Log.e(TAG, "onResume()");  
57.         super.onResume();  
58.         //恢复活动需要，但是当它处于不活动状态时被挂起的暂停的UI更新，线程或进程  
59.     }  
60.   
61.     //在活动生命周期结束的时候调用，用来保存UI状态的改变  
62.     @Override  
63.     protected void onSaveInstanceState(Bundle outState) {  
64.         super.onSaveInstanceState(outState);  
65.         //把UI改变状态保存到outState  
66.         //如果进程被终止并被启动，那么这个Bundle将被传递给onCreate  
67.     }  
68.       
69.     //在活动状态生存期结束时调用  
70.     @Override  
71.     protected void onPause() {  
72.         Log.e(TAG, "onPause()");  
73.         //当活动不是前台的活动状态的活动时  
74.         //挂起不需要更新的UI更新，线程或者CPU密集的进程  
75.         super.onPause();  
76.     }  
77.   
78.     //在可以生存期结束时调用  
79.     @Override  
80.     protected void onStop() {  
81.         Log.e(TAG, "onStop()");  
82.         //当活动不可见时，挂起不需要的UI更新，线程或处理  
83.         //保存所有的编辑或者状态改变，因为在调用这个方法后，进程可能就会被终止  
84.         super.onStop();  
85.     }  
86.   
87.     //在完整生存周期结束时调用  
88.     @Override  
89.     protected void onDestroy() {  
90.         Log.e(TAG, "onDestroy()");  
91.         //清理所有资源，包括结束线程，关闭数据库连接等  
92.         super.onDestroy();  
93.     }  
94.   
95.     public void onClick(View v) {  
96.         if(v==btn1){  
97.             startActivity(new Intent(this,Activity2.class));  
98.         }else if(v==btn2){  
99.             startActivity(new Intent(this,Activity2.class));  
100.             finish();  
101.         }else if(v==btn3){  
102.             finish();             
103.         }  
104.           
105.     }  
106.           
107. }  

 

完整生存期：

活动完整生存期是指对onCreate方法第一次调用和对onDestory方法的最后一次嗲用之间的时间范围。在某种情况下，还有另一种可能，即一个活动的进程被终止，却没有调用onDestory方法。

可见生存期：

一个活动的可见生存期是指调用onStart和onStop之间的那段时间。在这个时间里，活动对用户是可见的，但是它有可能不具有焦点，或者它可能被部分遮住了。

活动生存期：

活动生存期是指调用onResume和onPause之间的那段时间。一个处于活动状态的活动是前台的，并且正在接收用户的输入事件。注意，尽量让onResume和onPause中的代码执行迅速，并且其中的代码尽可能的少，以保证在前台和后台之间进行切换的时候应用能够保持响应。

 

 

下面为生命周期的执行过程函数的调用：

1.启动过程：onCreate()->onStart()->onResume();如下图：

 

 

2.销毁过程：onPause->onStop()->onDestroy();

 

 

3.不销毁跳转到第二个Activity过程：onPause->onStop();

 

4.再从第二个activiy返回第一个Activity(在第一个Activity没有销毁的情况下)的过程：

onRestart()->onStart()->onResume();

 

5.按下home键执行的过程：onPause()->onStop();

 

6.按下返回键执行的过程：onPause()->onStop()->onDestroy();

 

 

 

OK就这么简单，还不懂的大家写一个项目自己测试慢慢摸索，基本上懂了这几个生命周期的过程对，Activiy的灵活使用开发应该没什么问题了。

 

下面再附上测试图：

第一个Activity如下:

 

第二个activiy: