android基础知识汇总-Activity篇（一）

一： Activity是什么？

Activity是应用程序中负责与用户交互的组件。也是android四大组件（Activity、 Service、 Content Provider、 BroadcastReceiver）之一。

二： Activity的生命周期

Activity的生命周期体现在下面七个回调方法，我们一一介绍。

onCreate(): 活动第一次被创建时调用。一般用来初始化数据，如加载布局、绑定视图、设置监听 等

onStart(): 活动由不可见变为可见的时候。

onResume(): 活动获得焦点，准备和用户交互的时候。

onPause(): 系统准备启动另一个活动的时候。

onStop(): 活动变的完全不可见的时候。（注意一定是 完全 不可见）

onDestroy(): 活动被销毁之前调用。一般用来释放资源，如取消Service绑定，注销 BroadcastReceiver，关闭其他进程 等。

onRestart(): 活动被重新启动的时候。

我们可以把七个生命周期简单的按照变化趋势分为：

正要变得可见（被启动）的周期 ：

onCreate() ---> onStart() ---> onResume() （第一次创建时）

onRestart() ---> onStart() ---> onResume() （被栈上面完全遮挡自己的activity返回时）

onResume()   （被不完全遮挡自己的activity返回时）

变得不可见 ：

onStop()  

这样介绍太生硬，我们举个例子研究一下。

ActivityA 有个 button ，并设置了单击事件的监听器，在监听器中添加代码，启动 ActivityB 。

然后 ActivityB 的 onCreate() 方法中添加代码启动 ActivityC 并在 onResume() 方法中写上 finish() ，

ActivityC 的onStart() 方法中添加代码启动 ActivityD  并在 onPause() 方法中写上 finiish() 。

最后按下 back 键，会发生什么呢？

我们先用代码验证，然后再分析。代码如下

1. 创建MyTestActivity继承正常Activity，里面利用log在各个生命周期进行打印。

package com.example.administrator.csdn01;

import android.content.Intent;
import android.os.Bundle;
import android.support.v7.app.AppCompatActivity;
import android.util.Log;

public class MyTestActivity extends AppCompatActivity {
String TAG = "---->" + this.getClass().getName();
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
Log.d(TAG, "onCreate: ");
}

@Override
protected void onStart() {
super.onStart();
Log.d(TAG, "onStart: ");
}

@Override
protected void onResume() {
super.onResume();
Log.d(TAG, "onResume: ");
}

@Override
protected void onPause() {
super.onPause();
Log.d(TAG, "onPause: ");
}

@Override
protected void onStop() {
super.onStop();
Log.d(TAG, "onStop: ");
}

@Override
protected void onDestroy() {
super.onDestroy();
Log.d(TAG, "onDestroy: ");
}

@Override
protected void onRestart() {
super.onRestart();
Log.d(TAG, "onRestart: ");
}
protected <T> void MyIntent(Class<T> cls){
Intent intent = new Intent(this, cls);
startActivity(intent);
}
}

2. 创建ActivityA继承 MyTestActivity，并重写相关方法。

public class ActivityA extends MyTestActivity {
<
4000
span style="color:#000080;">private Button button;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activitya);
button = (Button)findViewById(R.id.button);
button.setOnClickListener(new View.OnClickListener(){
@Override
public void onClick(View v) {
MyIntent(ActivityB.class);
}
});
}
}

3. 创建ActivityB

public class ActivityB extends MyTestActivity {

@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_b);
MyIntent(ActivityC.class);
}

@Override
protected void onResume() {
super.onResume();
finish();
}
}

4. 创建ActivityC

public class ActivityC extends MyTestActivity {

@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_c);
}

@Override
protected void onStart() {
super.onStart();
MyIntent(ActivityD.class);
}

@Override
protected void onPause() {
super.onPause();
finish();
}
}

5. 创建ActivityD。D里面我们可以什么都不用写

public class ActivityD extends MyTestActivity {

@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_d);
}
}

6.运行，并点击按钮。观察logcat结果。

（1）启动程序



（2）清空logcat ，然后按下 button 按钮



（3）按下 Back 按键



现在我们可以来一步一步来分析：

1. ActivityA 能正常启动，显示界面。所以肯定会执行：

A.onCreate();  A.onStart();  A.onResume ......

2. 按下 ActivityA 的 button 按钮，启动ActivityB。肯定会执行：

A.onPause();  B.onCreate();  B.onStart();  B.onResume();  ......

3. ActivityB 的 正要变得可见的周期内部（onCreate方法的时候） 有启动ActivityC的代码，所以，会执行：

B.onPause();  C.onCreate();  C.onStart();   C.onResume(); ......

4. ActivityC 的 正要变得可见的周期内部（onStart方法的时候）。有启动 ActivityD 的代码，所以会执行：

C.onPause();  D.onCreatr();  D.onStart();   D.onResume(); ......

5. 这时候ActivityD 已经完全可见了，所以会依次执行变得不可见的 activity
的onStop() 方法，执行 A.onStop();  B.onStop();  C.onStop(); 本来会这样执行，但是，因为B和C执行过 finish() 方法，所以会插队依次执行 finish() 。所以最终会是：

B.onStop();  B.onDestroy();  ---（由 B.finish() 提供）

C.onStop();  C.onDestroy();  ---（由 C.finish() 提供）  

A.onStop();......

6. 现在已经启动完成了，这时候我们看到的界面是 ActivityD。这时按下 Back 就简单了。因为 B 和 C 都被 onDestory() 了，所以栈里面没有 B 和 C 。也就是说Back 会从D直接返回到 A。

D.onPause();  A.onRestart();  A.onStart(); A.onResume(); ......

7. 这时候D已经完全不可见了，所以会执行：

D.onStop(); ......

8. 因为 D 本来在栈的顶端，所以 Back 会将它从栈弹出，会执行：

D.onDestroy()

好了，我们来总结一下。启动一个 activity分为三个阶段，1、暂停旧的，2、启动新的，3.停止旧的（只有在被完全遮挡的时候才执行，否则不执行。如果有必要会紧接着摧毁旧的）：

OldActivity启动NewActivity：

Old.onPause （阶段一）---> New.onCreate ---> New.onStart ---> New.onResume （阶段二）---> Old.onStop（阶段三）

如果阶段二里面有启动其他Activity的代码，会直接执行下一轮的阶段一和阶段二，最后依次执行阶段三。