安卓系列转载，有时间可以参考学习

一：Activity的生命周期方法

 Android提供了很多Activity的生命周期方法，比如我们常用的onCreate、onPause、onResume等。这里主要介绍粗粒度的周期方法，诸如onPostCreate、onPostResume等
这些细粒度的周期方法可以参考Android的API文档，在你需要更细层次的控制的时候可以使用这些细粒度的方法。粗粒度的周期方法有以下几个：
onCreate()、onStart()、onResume()、onPause()、onStop()、onDestroy()，从名字上就可以看出来这些方法在什么时候执行。

二：测试Activity的生命周期方法的执行顺序

为了能更明白上这几个周期放的执行顺序，我们新建一个HelloWorld项目，在Activity中覆盖这几个方法，打印出日志就可以看出来执行顺序了

1. 新建HelloWorld项目，详细步骤可以参见：
   

   Android教程之三：第一个Android应用，HelloWorld

2. 修改main.xml内容为： 
   
   Xml代码  

   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="第一个Activity"  
   11.     />  
   12. <Button   
   13.     android:id="@+id/second"  
   14.     android:layout_width="wrap_content"  
   15.     android:layout_height="wrap_content"  
   16.     android:text="打开第二个Activity"/>  
   17. </LinearLayout>  
    
   这里主要是为增加一个文本显示和一个按钮用于显示信息和操作。
3. 新建布局文件second.xml，内容如下：
   Xml代码  

   1. <?xml version="1.0" encoding="utf-8"?>  
   2. <LinearLayout  
   3.   xmlns:android="http://schemas.android.com/apk/res/android"  
   4.   android:orientation="vertical"  
   5.   android:layout_width="fill_parent"  
   6.   android:layout_height="fill_parent">  
   7.   <TextView    
   8.     android:layout_width="fill_parent"   
   9.     android:layout_height="wrap_content"   
   10.     android:text="第二个Activity"  
   11.     />  
   12. <Button   
   13.     android:id="@+id/exit"  
   14.     android:layout_width="wrap_content"  
   15.     android:layout_height="wrap_content"  
   16.     android:text="退出"/>  
   17. </LinearLayout>  
    这里主要是为增加一个文本显示和一个退出按钮用于退出当前Activity。
4. 新建一个Activity，名字为SecondActivity，内容如下: 
   
   Java代码  

   1. public class SecondActivity extends Activity {  
   2.     private final static String TAG="SecondActivity";  
   3.     @Override  
   4.     protected void onCreate(Bundle savedInstanceState) {  
   5.         super.onCreate(savedInstanceState);  
   6.         Log.v(TAG, "onCreate");  
   7.         setContentView(R.layout.second);  
   8.         //退出按钮  
   9.         Button btnExit=(Button)findViewById(R.id.exit);  
   10.         //为退出按钮设置单击事件  
   11.         btnExit.setOnClickListener(new OnClickListener() {  
   12.             @Override  
   13.             public void onClick(View v) {  
   14.                 finish();//关闭当前Activity，也就是退出  
   15.             }  
   16.         });  
   17.     }  
   18.     @Override  
   19.     protected void onStart() {  
   20.         super.onStart();  
   21.         Log.v(TAG, "onStart");  
   22.     }  
   23.     @Override  
   24.     protected void onResume() {  
   25.         super.onResume();  
   26.         Log.v(TAG, "onResume");  
   27.     }  
   28.     @Override  
   29.     protected void onPause() {  
   30.         super.onPause();  
   31.         Log.v(TAG, "onPause");  
   32.     }  
   33.     @Override  
   34.     protected void onStop() {  
   35.         super.onStop();  
   36.         Log.v(TAG, "onStop");  
   37.     }  
   38.     @Override  
   39.     protected void onDestroy() {  
   40.         super.onDestroy();  
   41.         Log.v(TAG, "onDestroy");  
   42.     }  
   43.       
   44. }  
    我在各个周期方法了都加了日志信息，便于跟踪Activity的运行过程
5. 修改HelloWorld类，内容如下：
   Java代码  

   1. public class HelloWorld extends Activity {  
   2.     private final static String TAG="HelloWorld";  
   3.     /** Called when the activity is first created. */  
   4.     @Override  
   5.     public void onCreate(Bundle savedInstanceState) {  
   6.         super.onCreate(savedInstanceState);  
   7.         Log.v(TAG, "onCreate");  
   8.         setContentView(R.layout.main);  
   9.         //打开第二个Activity的按钮  
   10.         Button btnSecond=(Button)findViewById(R.id.second);  
   11.         //设置单击事件  
   12.         btnSecond.setOnClickListener(new OnClickListener() {  
   13.             @Override  
   14.             public void onClick(View v) {  
   15.                 startActivity(new Intent(HelloWorld.this,SecondActivity.class));  
   16.                 finish();//关闭当前Activity  
   17.             }  
   18.         });  
   19.     }  
   20.     @Override  
   21.     protected void onStart() {  
   22.         super.onStart();  
   23.         Log.v(TAG, "onStart");  
   24.     }  
   25.     @Override  
   26.     protected void onResume() {  
   27.         super.onResume();  
   28.         Log.v(TAG, "onResume");  
   29.     }  
   30.     @Override  
   31.     protected void onPause() {  
   32.         super.onPause();  
   33.         Log.v(TAG, "onPause");  
   34.     }  
   35.     @Override  
   36.     protected void onStop() {  
   37.         super.onStop();  
   38.         Log.v(TAG, "onStop");  
   39.     }  
   40.     @Override  
   41.     protected void onDestroy() {  
   42.         super.onDestroy();  
   43.         Log.v(TAG, "onDestroy");  
   44.     }  
   45. }  
6. 运行程序，分析结果，发现当程序启动的时候，日志信息为下图: 
   
    由此可见当打开一个Activity的时候，其周期方法执行顺序为：onCreate()->onStart()->onResume(),现在点击“打开第二个Activity”按钮，看日志的输出如下图: 
   
    当应用从Helloworld这个Activity启动SecondActivity的时候，Android会先执行HelloWorld的onPause方法，然后依次执行SecondActivity的onCreate()->onStart()->onResume()方法
   当SecondActivity呈现到屏幕上的时候再一次执行Helloworld的onStop()->onDestroy(),把HelloWorld从Activity栈中移除销毁。这里值得提的就是HelloWorld 中finish方法，因为执行了他所以
   HelloWorld才会从Activity栈中移除销毁，这样当你按“返回”键返回的时候就回不到HelloWorld 这个Activity的界面了，而是直接回到的Android的应用程序列表 。

三：分析结果

根据上面例子可见一个Activity在启动的时候会执行onCreate()->onStart()->onResume()，在结束（或离开）的时候会执行onPause()->onStop()->onDestroy(),这就是一个Activity的生命周期。
因此我们要在onCreate方法里把Activity的需要的东西准备好，也就是初始化；在onResume里对Activity里的东西做一些调整；在onPause做一些清理和保存工作(保存持久状态),因为这是最后的
机会，因为onPause完成之前Android不会结束托管Activity类的进程，而之后进程可能被结束。总结一下这几个周期方法的作用：

1.  
   1. onCreate():创建Activity调用，用于Activity的初始化，还有个Bundle类型的参数，可以访问以前存储的状态。
   2. onStart():Activity在屏幕上对用户可见时调用
   3. onResume():Activity开始和用户交互的时候调用，这时该Activity是在Activity栈的顶部。
   4. onPause():Activity被暂停时调用，也就是你要对你能看到的这个Activity说byebye的时候调用,这里可以做一些清理和保存工作
   5. onStop():Activity被停止或者Activity变成不可见时调用
   6. onDestroy():Activity被从内存中移除，一般发生在执行finish方法时或者Android回收内存的时候

好了，最后让我们看一个API提供的Activity的状态图吧，看了他相信你对Activity的生命周期会更了解，如下图： 

 

四：小结

这节主要是通过一个例子分析Activity声明周期，并对常用生命周期方法做了一些说明，应该什么时候使用他们。到这里Android的很基础的东西已经说完了，

本文转载地址：

http://android.group.iteye.com/group/wiki/2890-android-activity-life-cycle