关于activity的生命周期一

anctivity的生命周期比较复杂，但是很好的理解其生命周期，对于我们设计性能优良的应用程序有很大的帮助。
下面是官方文档上的一幅比较经典的activity生命周期示意图：


其中涉及到七个生命周期函数，下面摘自官方文档的介绍：

Method			Description	Killable?	Next
onCreate()			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().	No	onStart()
	onRestart()		Called after your activity has been stopped, prior to it being started again. Always followed by onStart()	No	onStart()
	onStart()		Called when the activity is becoming visible to the user. Followed by onResume() if the activity comes to the foreground, or onStop() if it becomes hidden.	No	onResume()or onStop()
		onResume()	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().	No	onPause()
		onPause()	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.	Yes	onResume()or onStop()
	onStop()		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, oronDestroy() if this activity is going away.	Yes	onRestart()or onDestroy()
onDestroy()			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.	Yes	nothing

文档上已经很了然介绍了各函数的作用，什么时候被调用等，下面简单的总结一下：
1.onCreate()
Activity首次被创建时被调用，用于设置activity的布局文件，绑定按钮监听器等一些静态操作
2.onStart()
Activity对用户可见时被调用
3.onResume()
Activity获得用户焦点，即用户可以操作activity时被调用
4.onPause()
应用程序启动了其他activity时被调用。一般用于当前activity中的数据
5.onStop()
activity不可见时被调用
6.onRestart()
已停止的activity重新启动被调用
7.onDestroy()
调用activity的finish()方法或者android系统资源不足的时候被调用

我们通过简单的实验来说明一下：

下面的实验是创建两个activity,跳转的过程中，通过activity生命周期函数来说明activity的生命过程。由于布局很简单，下面只给出截图：
activity_main.xml:


two.xml:


MainActivity:(下面通过重写activity生命周期函数，来打印各个过程）

点击(此处)折叠或打开

1. package com.example.android02;
   
2. 
   
3. import org.apache.commons.logging.Log;
   
4. 
   
5. import android.app.Activity;
   
6. import android.content.Intent;
   
7. import android.os.Bundle;
   
8. import android.view.View;
   
9. import android.view.View.OnClickListener;
   
10. import android.widget.Button;
    
11. import android.widget.TextView;
    
12. 
    
13. public class MainActivity extends Activity {
    
14. 
    
15.     @Override
    
16.     protected void onCreate(Bundle savedInstanceState) {
    
17.         super.onCreate(savedInstanceState);
    
18.         setContentView(R.layout.activity_main);
    
19.         //Log.i(TAG,"onCreat");
    
20.         TextView text = (TextView)findViewById(R.id.text1);
    
21.         text.setText(R.string.number1);
    
22.         Button button = (Button)findViewById(R.id.one);
    
23.         button.setText(R.string.change);
    
24.         button.setOnClickListener(new wang());
    
25.         
    
26.     }
    
27.     
    
28.     class wang implements OnClickListener{
    
29.         
    
30.         public void onClick(View v){
    
31. 
    
32.             Intent intent = new Intent();
    
33.             intent.setClass(MainActivity.this,TwoActivity.class);
    
34.             MainActivity.this.startActivity(intent);
    
35. 
    
36.             }
    
37.         
    
38.         //public 
    
39.         
    
40. 
    
41.     }
    
42.     
    
43.     protected void onStart() {
    
44.         super.onStart();
    
45.          System.out.println("first activity --》 onstart");
    
46.         // The activity is about to become visible.
    
47.     }
    
48.     @Override
    
49.     protected void onResume() {
    
50.         super.onResume();
    
51.         System.out.println("first activity -->onresume");
    
52.         // The activity has become visible (it is now "resumed").
    
53.     }
    
54.     @Override
    
55.     protected void onPause() {
    
56.         super.onPause();
    
57.         System.out.println("first activity -->onpause");
    
58.         // Another activity is taking focus (this activity is about to be "paused").
    
59.     }
    
60.     @Override
    
61.     protected void onStop() {
    
62.         super.onStop();
    
63.         System.out.println("first activity -->onstop");
    
64.         // The activity is no longer visible (it is now "stopped")
    
65.     }
    
66.      protected void onRestart(){
        super.onRestart();
        System.out.println("first activity -->restart");
        
        }
    
67.     @Override
    
68.     protected void onDestroy() {
    
69.         super.onDestroy();
    
70.         System.out.println("first activity -->ondestory");
    
71.         // The activity is about to be destroyed.
    
72.     }
    
73. }

TwoActivity:

点击(此处)折叠或打开

1. package com.example.android02;
   
2. 
   
3. import android.app.Activity;
   
4. import android.os.Bundle;
   
5. import android.widget.Button;
   
6. import android.widget.TextView;
   
7. 
   
8. public class TwoActivity extends Activity{
   
9.     
   
10.     
    
11.     @Override
    
12.     protected void onCreate(Bundle savedInstanceState) {
    
13.         super.onCreate(savedInstanceState);
    
14.         setContentView(R.layout.two);
    
15.         TextView text = (TextView)findViewById(R.id.text2);
    
16.         text.setText(R.string.number2);
    
17.         @SuppressWarnings("unused")
    
18.         Button button = (Button)findViewById(R.string.button2);
    
19.     }
    
20.     
    
21.     protected void onStart() {
    
22.         super.onStart();
    
23.          System.out.println("second activity --》 onstart");
    
24.         // The activity is about to become visible.
    
25.     }
    
26.     @Override
    
27.     protected void onResume() {
    
28.         super.onResume();
    
29.         System.out.println("second activity -->onresume");
    
30.         // The activity has become visible (it is now "resumed").
    
31.     }
    
32.     @Override
    
33.     protected void onPause() {
    
34.         super.onPause();
    
35.         System.out.println("second activity -->onpause");
    
36.         // Another activity is taking focus (this activity is about to be "paused").
    
37.     }
    
38.     @Override
    
39.     protected void onStop() {
    
40.         super.onStop();
    
41.         System.out.println("second activity -->onstop");
    
42.         // The activity is no longer visible (it is now "stopped")
    
43.     }
    
44.      protected void onRestart(){
        super.onRestart();
        System.out.println("second activity -->restart");
        
        }
    
45.     @Override
    
46.     protected void onDestroy() {
    
47.         super.onDestroy();
    
48.         System.out.println("second activity -->ondestory");
    
49.         // The activity is about to be destroyed.
    
50.     }
    
51. }

此时我们通过运行程序，通过Logcat可以看出打印出的各个生命周期阶段：

启动后，日志输出：(第一个activity经历了oncreate,onstart,onresume，获得焦点）

点击按钮然后进入第二个activity:(第一个activity可以是可见，但是失去了焦点，第二个activity获得了焦点）

此时点击back键：（此时第二个activity会失去焦点。而第一个activity之前被stop，此时会onrestart,重新获得焦点。从上面的activity生命图解可以很清楚的看出整个过程。这方面涉及到activity和Task相关知识，task以栈的形式存在，先启动的activity会先入栈，最后启动的activity会放在栈顶。上面第二个activity进栈的时候，此时完全遮盖了第一个activity，所以导致了第一个activity被onstop,但是没有被销毁，这也是当第二个activity出栈，失去焦点后，第一个activity restart，而没有oncreate的原因）