android学习——Activity生命周期小谈

转载自：http://cxshun.iteye.com/blog/1132613

android学习——Activity生命周期小谈

• 博客分类：
• android学习

忙了一段时间，终于抽出一段时间对自己前段时间的学习做一下总结了。前段时间趁着晚上有时间，学习了一下android，感觉蛮有意思的。了解了四个基本的元素，Activity，Content Provider，Broadcase Receiver，Services。今天，我们一起来看一下Activity的生命周期，为什么要看这个呢？我想学过servlet的童鞋都知道，我们当时在学习servlet的时候也是从生命周期开始的，首先知道请求的顺序，然后知道怎么处理请求的。只有这样我们才能在需要的时候做一些相关的事情。

android的学习也是这样，Activity是android中最重要的，一般情况下都表示一个界面，这样，我们如果需要进行什么处理都需要在activity上进行处理。下面我们来看一下具体的代码。

1）先建一个项目吧，名称就随便啦。Activity也随便，反正自己看得懂就OK了。

我建了一个结构如图：

这里的名称是随便的，不必追求一致。

2）大家看到我有两个Activity，前面也讲了Activity是一个界面，那么两个当然就是两个界面啦。

看代码之前，我们先来看看Activity事件的方法，有如下几个：

Java代码  

1. public void onCreate(Bundle savedInstanceState) ;  
2. public void onDestroy();  
3. public void onPause();  
4. public void onRestart();  
5. public void onResume();  
6. public void onStart();  
7. public void onStop();  

   这些方法，我们看方法名大概就可以猜到那个方法是在什么时候调用的了。但真正要理解却不是那么简单的。

下面开始我们的正题，看代码啦。

首先看一下strings.xml，这里定义了我们需要显示的字符串。

Xml代码  

1. <?xml version="1.0" encoding="utf-8"?>  
2. <resources>  
3.     <string name="hello">Hello World, MainActivity!</string>  
4.     <string name="app_name">Activity生命周期</string>  
5.     <string name="other">另外一个Activity</string>  
6.     <string name="start">启动另一个Activity</string>  
7.     <string name="stop">结束当前Activity</string>  
8. </resources>  

  前面两个可有可无了，只是创建后没有进行修改。

我们来看一下界面的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.     <Button  
8.         android:layout_width="wrap_content"  
9.         android:layout_height="wrap_content"  
10.         android:text="@string/start"  
11.         android:id="@+id/start"  
12.         />  
13.     <Button  
14.         android:layout_width="wrap_content"  
15.         android:layout_height="wrap_content"  
16.         android:text="@string/stop"  
17.         android:id="@+id/stop"  
18.         />  
19. </LinearLayout>  

  这里大家应该大概都可以看得懂啦，非常简单的，就两个按钮而已，一个是开始另一个Activity，另一个是停止当前的Activity。非常简单，如果这里看不懂，就需要先补充一下android的基本知识啦。

还有一个是androidManifest.xml这个是最主要的，因为我们用了两个Activity，两个都需要在这里进行“注册”，否则将不可使用。

Xml代码  

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

注意，这里的Activity的顺序跟你启动的顺序有关，我这里需要以MainActivity来启动，所以放在OtherActivity前面。

3）这里我们看完了界面代码，接下来便是我们最主要的代码啦。MainActivity和OtherActivity。我们通过MainActivity来进行启动。点击开始另一个Activity则启动OtherActivity。停止则相应的停止当前的Activity。

下面是MainActivity的代码：

Java代码  

1. package com.shun.android;  
2.   
3. import android.app.Activity;  
4. import android.content.Intent;  
5. import android.os.Bundle;  
6. import android.util.Log;  
7. import android.view.View;  
8. import android.widget.Button;  
9.   
10. public class MainActivity extends Activity {  
11.     private static final String TAG = "MainActivity";  
12.     @Override  
13.     public void onCreate(Bundle savedInstanceState) {  
14.         super.onCreate(savedInstanceState);  
15.         setContentView(R.layout.main);  
16.           
17.         Log.i(TAG,"onCreate");  
18.           
19.         Button start = (Button)findViewById(R.id.start);  
20.         start.setOnClickListener(new View.OnClickListener() {  
21.               
22.             public void onClick(View v) {  
23.                 Intent intent = new Intent(MainActivity.this,OtherActivity.class);  
24.                 startActivity(intent);  
25.                 MainActivity.this.finish();  
26.             }  
27.         });  
28.           
29.         Button stop = (Button)findViewById(R.id.stop);  
30.         stop.setOnClickListener(new View.OnClickListener() {  
31.               
32.             public void onClick(View v) {  
33.                 MainActivity.this.finish();  
34.             }  
35.         });  
36.           
37.     }  
38.       
39.     protected void onDestroy(){  
40.         Log.i(TAG,"onDestroy");  
41.         super.onDestroy();  
42.     }  
43.       
44.     protected void onPause(){  
45.         Log.i(TAG,"onPause");  
46.         super.onPause();  
47.     }  
48.       
49.     protected void onRestart(){  
50.         Log.i(TAG,"onRestart");  
51.         super.onRestart();  
52.     }  
53.       
54.     protected void onResume(){  
55.         Log.i(TAG,"onResume");  
56.         super.onResume();  
57.     }  
58.       
59.     protected void onStart(){  
60.         Log.i(TAG,"onStart");  
61.         super.onStart();  
62.     }  
63.       
64.     protected void onStop(){  
65.         Log.i(TAG,"onStop");  
66.         super.onStop();  
67.     }  
68. }  

  OtherActivity代码如下：

Java代码  

1. package com.shun.android;  
2.   
3. import android.app.Activity;  
4. import android.content.Intent;  
5. import android.os.Bundle;  
6. import android.util.Log;  
7. import android.view.View;  
8. import android.widget.Button;  
9.   
10. public class OtherActivity extends Activity{  
11.   
12.     private static final String TAG = "OtherActivity";  
13.     @Override  
14.     public void onCreate(Bundle savedInstanceState) {  
15.         super.onCreate(savedInstanceState);  
16.         setContentView(R.layout.main);  
17.           
18.         Log.i(TAG,"onCreate");  
19.           
20.         Button start = (Button)findViewById(R.id.start);  
21.         start.setOnClickListener(new View.OnClickListener() {  
22.               
23.             public void onClick(View v) {  
24.                 Intent intent = new Intent(OtherActivity.this,MainActivity.class);  
25.                 startActivity(intent);  
26.                 OtherActivity.this.finish();  
27.             }  
28.         });  
29.           
30.         Button stop = (Button)findViewById(R.id.stop);  
31.         stop.setOnClickListener(new View.OnClickListener() {  
32.               
33.             public void onClick(View v) {  
34.                 OtherActivity.this.finish();  
35.             }  
36.         });  
37.           
38.     }  
39.       
40.     protected void onDestroy(){  
41.         Log.i(TAG,"onDestroy");  
42.         super.onDestroy();  
43.     }  
44.       
45.     protected void onPause(){  
46.         Log.i(TAG,"onPause");  
47.         super.onPause();  
48.     }  
49.       
50.     protected void onRestart(){  
51.         Log.i(TAG,"onRestart");  
52.         super.onRestart();  
53.     }  
54.       
55.     protected void onResume(){  
56.         Log.i(TAG,"onResume");  
57.         super.onResume();  
58.     }  
59.       
60.     protected void onStart(){  
61.         Log.i(TAG,"onStart");  
62.         super.onStart();  
63.     }  
64.       
65.     protected void onStop(){  
66.         Log.i(TAG,"onStop");  
67.         super.onStop();  
68.     }  
69.       
70. }  

  代码没啥好讲的罗，很简单的。主要还是要理解生命周期。

下面我们看一下运行的效果：

当我们进行启动的时候：

它首先启动onCreate，其次是onStart，再来就是onResume。这三个特定，不用怀疑。

界面如下：

这时我们点击启动另一个Activity看看效果，这里是MainActivity，点击后将会跳转到OtherActivity。

我们看看效果：

这里已经跳转到另一个Activity，因为我们用了同样的layout，所以显示的是一样的，只是标题不一样。

    我们来看看它的信息：

  我们看到MainActivity会首先暂停，然后再进行新的Activity的创建过程，创建完成后就调用销毁MainActivity。

 

大家估计会怀疑，因为我在MainActivity中把finish写在startActivity后面，肯定是因为这个才在后面调用stop的。首先不是肯定的这么快，我们来把finish放到前面来看看。

我们把MainActivity中的onCreate中的部分代码修改成下面的：

Java代码  

1. start.setOnClickListener(new View.OnClickListener() {  
2.               
3.             public void onClick(View v) {  
4.                 MainActivity.this.finish();  
5.                 Intent intent = new Intent(MainActivity.this,OtherActivity.class);  
6.                 startActivity(intent);  
7.             }  
8.         });  

  这里我们把finish放到前面了，我们重新运行后可以看到效果：

  我们看到效果是一样的。但为了代码的易读，建议还是放到后面，符合生命周期的调用顺序。

 

现在我们在OtherActivity中，我们想要回到MainActivity中，还是同样启动另一个Activity：

  这里的调用过程也是一样，首先暂停，创建，最后销毁。

现在我们直接关闭MainActivity有：

  这里我们看到它首先调用onPause方法，之后才是正式停止和销毁。从这里我们猜想，当发生一个Activity的切换时，都会先调用当前Activity的onPause方法。这里，我们先不说正不正确，接下去看看，实践证明一切。

 

4）我们在前面是手动finish了这个Activity，下面我们不结束了，我们看看修改的代码：

OtherActivity中还是会调用finish来销毁这个页面，因为不需要了。

OtherActivity如下：

Java代码  

1. Button start = (Button)findViewById(R.id.start);  
2.         start.setOnClickListener(new View.OnClickListener() {  
3.               
4.             public void onClick(View v) {  
5.                 OtherActivity.this.finish();  
6.             }  
7.         });  

  MainActivity如下：

Java代码  

1. Button start = (Button)findViewById(R.id.start);  
2.         start.setOnClickListener(new View.OnClickListener() {  
3.               
4.             public void onClick(View v) {  
5.                 Intent intent = new Intent(MainActivity.this,OtherActivity.class);  
6.                 startActivity(intent);  
7.             }  
8.         });  

  这样我们就改好了，其他地方并不需要修改。

我们看看效果，当我们启动MainActivity后，我们点击启动另一个Activity来启动OtherActivity，我们来看看信息：

  我们看到它并没有调用onDestroy，这表明这个onDestroy是当我们调用finish方法才会调用的。

下面我们在OtherActivity中点击启动另一个Activity来启动另一个Activity，注意，这里的“启动”并不是真正启动，不是通过startActivity来启动的，只是结束当前的Activity。

我们看看信息：

这里我们再点击启动另一个Activity，实际上只是停止当前的OtherActivity。我们看看打印出来的信息：

这里我们看到它并不是调用MainActivity的onCreate方法，因为MainActivity并没有被销毁，而只是停止了而已。当OtherActivity被销毁，要切换的时候，会重新启动MainActivity。这时就会调用onRestart。

 

5）注意，我们这里以把OtherActivity作为一个整的Activity，即是占整个界面的。下面我们来看另外一种情况，即我们启动的是一个对话框。

我们需要修改androidManifest.xml，修改后如下：

Xml代码  

1. <activity android:name=".OtherActivity"  
2.                   android:label="@string/other"  
3.                   android:theme="@android:style/Theme.Dialog">  
4.         </activity>  

  只需要修改OtherActivity的定义即可，这里我们把它定义成Dialog即对话框类型，它并不会占据整个界面，而原来的Activity后退到后台运行。

为了效果的演示，我们先把MainActivity中启动另一个Activity中的finish代码去掉，而把OtherActivity中的启动另一个Activity的代码去掉，留下finish代码。这样就可以看到重新启动的效果。

去掉后的代码如下：

MainActivity中的部分代码：

Java代码  

1. Button start = (Button)findViewById(R.id.start);  
2.         start.setOnClickListener(new View.OnClickListener() {  
3.               
4.             public void onClick(View v) {  
5.                 Intent intent = new Intent(MainActivity.this,OtherActivity.class);  
6.                 startActivity(intent);  
7.             }  
8.         });  

  OtherActivity中的代码：

Java代码  

1. Button start = (Button)findViewById(R.id.start);  
2.         start.setOnClickListener(new View.OnClickListener() {  
3.               
4.             public void onClick(View v) {  
5.                 OtherActivity.this.finish();  
6.             }  
7.         });  

  我们运行后点击启动另一个Activity可以看到：

  这里我们看到MainActivity只调用了一个onPause，也就是说它并没有停止，只是在后台运行。

我们看效果：

我们看到主的Activity跑到后面并形成半透明的状态，这是它正在后台运行。

当我们点击启动另一个Activity，注意，我们这里并不启动另一个Activity，而只是直接结束当前的Activity。

现在当我们点击启动另一个Activity时，当前的OtherActivity会关闭，而回到原来的MainActivity。

我们来看看效果：

而后台的信息如下：

    它直接调用onResume重新恢复MainActivity，而不是重新启动。这是因为MainActivity还在后台运行，我们不需要再重新启动一个。

 

其实这个生命周期并不难，难的是每个阶段要理解。随着接触的东西越来越多，相信对这个周期的理解会越来越深的。

下面给一个android官方的生命周期的图大家一起学习：

有了上面的例子，相信理解起来应该不难。