Activity的生命周期方法

一: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.                 
    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的时候,将依次执行:(First指第一个MainActivity,Second指第二个)

First.onPause(); //在要调用另一个Activity时调用;

Second.onCreate();

Second.onStart(); //被看到

Second.onResume();

First.onStop(); //对应onStart(),是在Activity对用户不可见时调用;

 

三:分析结果

根据上面例子可见一个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的生命周期方法_第1张图片

 

你可能感兴趣的:(安卓开发)