420455人阅读
Android（31）
子曰：溫故而知新，可以為師矣。《論語》
学习技术也一样，对于技术文档或者经典的技术书籍来说，指望看一遍就完全掌握，那基本不大可能，所以我们需要经常回过头再仔细研读几遍，以领悟到作者的思想精髓。
近来回顾了一下关于Activity的生命周期，参看了相关书籍和官方文档，也有了不小的收获，对于以前的认知有了很大程度上的改善，在这里和大家分享一下。
熟悉javaEE的朋友们都了解servlet技术，我们想要实现一个自己的servlet，需要继承相应的基类，重写它的方法，这些方法会在合适的时间被servlet容器调用。其实android中的Activity运行机制跟servlet有些相似之处，Android系统相当于servlet容器，Activity相当于一个servlet，我们的Activity处在这个容器中，一切创建实例、初始化、销毁实例等过程都是容器来调用的，这也就是所谓的“Don't call me, I'll call you.”机制。
我们来看一下这一张经典的生命周期流程图：
相信不少朋友也已经看过这个流程图了，也基本了解了Activity生命周期的几个过程，我们就来说一说这几个过程。
1.启动Activity：系统会先调用onCreate方法，然后调用onStart方法，最后调用onResume，Activity进入运行状态。
2.当前Activity被其他Activity覆盖其上或被锁屏：系统会调用onPause方法，暂停当前Activity的执行。
3.当前Activity由被覆盖状态回到前台或解锁屏：系统会调用onResume方法，再次进入运行状态。
4.当前Activity转到新的Activity界面或按Home键回到主屏，自身退居后台：系统会先调用onPause方法，然后调用onStop方法，进入停滞状态。
5.用户后退回到此Activity：系统会先调用onRestart方法，然后调用onStart方法，最后调用onResume方法，再次进入运行状态。
6.当前Activity处于被覆盖状态或者后台不可见状态，即第2步和第4步，系统内存不足，杀死当前Activity，而后用户退回当前Activity：再次调用onCreate方法、onStart方法、onResume方法，进入运行状态。
7.用户退出当前Activity：系统先调用onPause方法，然后调用onStop方法，最后调用onDestory方法，结束当前Activity。
但是知道这些还不够，我们必须亲自试验一下才能深刻体会，融会贯通。
下面我们就结合实例，来演示一下生命周期的几个过程的详细情况。我们新建一个名为lifecycle的项目，创建一个名为LifeCycleActivity的Activity，如下：
package com.scott.
import android.app.A
import android.content.C
import android.content.I
import android.os.B
import android.util.L
import android.view.V
import android.widget.B
public class LifeCycleActivity extends Activity {
private static final String TAG = &LifeCycleActivity&;
private Context context =
private int param = 1;
//Activity创建时被调用
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
Log.i(TAG, &onCreate called.&);
setContentView(R.layout.lifecycle);
Button btn = (Button) findViewById(R.id.btn);
btn.setOnClickListener(new View.OnClickListener() {
public void onClick(View v) {
Intent intent = new Intent(context, TargetActivity.class);
startActivity(intent);
//Activity创建或者从后台重新回到前台时被调用
protected void onStart() {
super.onStart();
Log.i(TAG, &onStart called.&);
//Activity从后台重新回到前台时被调用
protected void onRestart() {
super.onRestart();
Log.i(TAG, &onRestart called.&);
//Activity创建或者从被覆盖、后台重新回到前台时被调用
protected void onResume() {
super.onResume();
Log.i(TAG, &onResume called.&);
//Activity窗口获得或失去焦点时被调用,在onResume之后或onPause之后
/*@Override
public void onWindowFocusChanged(boolean hasFocus) {
super.onWindowFocusChanged(hasFocus);
Log.i(TAG, &onWindowFocusChanged called.&);
//Activity被覆盖到下面或者锁屏时被调用
protected void onPause() {
super.onPause();
Log.i(TAG, &onPause called.&);
//有可能在执行完onPause或onStop后,系统资源紧张将Activity杀死,所以有必要在此保存持久数据
//退出当前Activity或者跳转到新Activity时被调用
protected void onStop() {
super.onStop();
Log.i(TAG, &onStop called.&);
//退出当前Activity时被调用,调用之后Activity就结束了
protected void onDestroy() {
super.onDestroy();
Log.i(TAG, &onDestory called.&);
* Activity被系统杀死时被调用.
* 例如:屏幕方向改变时,Activity被销毁再重建;当前Activity处于后台,系统资源紧张将其杀死.
* 另外,当跳转到其他Activity或者按Home键回到主屏时该方法也会被调用,系统是为了保存当前View组件的状态.
* 在onPause之前被调用.
protected void onSaveInstanceState(Bundle outState) {
outState.putInt(&param&, param);
Log.i(TAG, &onSaveInstanceState called. put param: & + param);
super.onSaveInstanceState(outState);
* Activity被系统杀死后再重建时被调用.
* 例如:屏幕方向改变时,Activity被销毁再重建;当前Activity处于后台,系统资源紧张将其杀死,用户又启动该Activity.
* 这两种情况下onRestoreInstanceState都会被调用,在onStart之后.
protected void onRestoreInstanceState(Bundle savedInstanceState) {
param = savedInstanceState.getInt(&param&);
Log.i(TAG, &onRestoreInstanceState called. get param: & + param);
super.onRestoreInstanceState(savedInstanceState);
}大家注意到，除了几个常见的方法外，我们还添加了onWindowFocusChanged、onSaveInstanceState、onRestoreInstanceState方法：
1.onWindowFocusChanged方法：在Activity窗口获得或失去焦点时被调用，例如创建时首次呈现在用户面前；当前Activity被其他Activity覆盖；当前Activity转到其他Activity或按Home键回到主屏，自身退居后台；用户退出当前Activity。以上几种情况都会调用onWindowFocusChanged，并且当Activity被创建时是在onResume之后被调用，当Activity被覆盖或者退居后台或者当前Activity退出时，它是在onPause之后被调用，如图所示：
这个方法在某种场合下还是很有用的，例如程序启动时想要获取视特定视图组件的尺寸大小，在onCreate中可能无法取到，因为窗口Window对象还没创建完成，这个时候我们就需要在onWindowFocusChanged里获取；如果大家已经看过我写的这篇文章就会知道，当时试图在onCreate里加载frame动画失败的原因就是因为窗口Window对象没有初始化完成，所以最后我将加载动画的代码放到了onWindowFocusChanged中，问题迎刃而解。不过大家也许会有疑惑，为什么我在代码里将它注释掉了，因为对当前Activity每一个操作都有它的执行log，我担心这会影响到整个流程的清晰度，所以将它注掉，大家只要了解它应用的场合和执行的顺序就可以了。
2.onSaveInstanceState：(1)在Activity被覆盖或退居后台之后，系统资源不足将其杀死，此方法会被调用；(2)在用户改变屏幕方向时，此方法会被调用；(3)在当前Activity跳转到其他Activity或者按Home键回到主屏，自身退居后台时，此方法会被调用。第一种情况我们无法保证什么时候发生，系统根据资源紧张程度去调度；第二种是屏幕翻转方向时，系统先销毁当前的Activity，然后再重建一个新的，调用此方法时，我们可以保存一些临时数据；第三种情况系统调用此方法是为了保存当前窗口各个View组件的状态。onSaveInstanceState的调用顺序是在onPause之前。
3.onRestoreInstanceState：(1)在Activity被覆盖或退居后台之后，系统资源不足将其杀死，然后用户又回到了此Activity，此方法会被调用；(2)在用户改变屏幕方向时，重建的过程中，此方法会被调用。我们可以重写此方法，以便可以恢复一些临时数据。onRestoreInstanceState的调用顺序是在onStart之后。
以上着重介绍了三个相对陌生方法之后，下面我们就来操作一下这个Activity，看看它的生命周期到底是个什么样的过程：
1.启动Activity：
在系统调用了onCreate和onStart之后，调用了onResume，自此，Activity进入了运行状态。
2.跳转到其他Activity，或按下Home键回到主屏：
我们看到，此时onSaveInstanceState方法在onPause之前被调用了，并且注意，退居后台时，onPause后onStop相继被调用。
3.从后台回到前台：
当从后台会到前台时，系统先调用onRestart方法，然后调用onStart方法，最后调用onResume方法，Activity又进入了运行状态。
4.修改TargetActivity在AndroidManifest.xml中的配置，将android:theme属性设置为@android:style/Theme.Dialog，然后再点击LifeCycleActivity中的按钮，跳转行为就变为了TargetActivity覆盖到LifeCycleActivity之上了，此时调用的方法为：
注意还有一种情况就是，我们点击按钮，只是按下锁屏键，执行的效果也是如上。
我们注意到，此时LifeCycleActivity的OnPause方法被调用，并没有调用onStop方法，因为此时的LifeCycleActivity没有退居后台，只是被覆盖或被锁屏；onSaveInstanceState会在onPause之前被调用。
5.按回退键使LifeCycleActivity从被覆盖回到前面，或者按解锁键解锁屏幕：
此时只有onResume方法被调用，直接再次进入运行状态。
最后onDestory方法被调用，标志着LifeCycleActivity的终结。
大家似乎注意到，在所有的过程中，并没有onRestoreInstanceState的出现，这个并不奇怪，因为之前我们就说过，onRestoreInstanceState只有在杀死不在前台的Activity之后用户回到此Activity，或者用户改变屏幕方向的这两个重建过程中被调用。我们要演示第一种情况比较困难，我们可以结合第二种情况演示一下具体过程。顺便也向大家讲解一下屏幕方向改变的应对策略。
首先介绍一下关于Activity屏幕方向的相关知识。
我们可以为一个Activity指定一个特定的方向，指定之后即使转动屏幕方向，显示方向也不会跟着改变：
1.指定为竖屏：在AndroidManifest.xml中对指定的Activity设置android:screenOrientation=&portrait&，或者在onCreate方法中指定：
setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_PORTRAIT); //竖屏2.指定为横屏：在AndroidManifest.xml中对指定的Activity设置android:screenOrientation=&landscape&，或者在onCreate方法中指定：
setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_LANDSCAPE); //横屏为应用中的Activity设置特定的方向是经常用到的办法，可以为我们省去不少不必要的麻烦。不过，我们今天讲的是屏幕方向改变时的生命周期，所以我们并不采用固定屏幕方向这种办法。
下面我们就结合实例讲解一下屏幕转换的生命周期，我们新建一个Activity命名为OrientationActivity，如下：
package com.scott.
import android.app.A
import android.content.res.C
import android.os.B
import android.util.L
public class OrientationActivity extends Activity {
private static final String TAG = &OrientationActivity&;
private int param = 1;
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.orientation_portrait);
Log.i(TAG, &onCreate called.&);
protected void onStart() {
super.onStart();
Log.i(TAG, &onStart called.&);
protected void onRestart() {
super.onRestart();
Log.i(TAG, &onRestart called.&);
protected void onResume() {
super.onResume();
Log.i(TAG, &onResume called.&);
protected void onPause() {
super.onPause();
Log.i(TAG, &onPause called.&);
protected void onStop() {
super.onStop();
Log.i(TAG, &onStop called.&);
protected void onDestroy() {
super.onDestroy();
Log.i(TAG, &onDestory called.&);
protected void onSaveInstanceState(Bundle outState) {
outState.putInt(&param&, param);
Log.i(TAG, &onSaveInstanceState called. put param: & + param);
super.onSaveInstanceState(outState);
protected void onRestoreInstanceState(Bundle savedInstanceState) {
param = savedInstanceState.getInt(&param&);
Log.i(TAG, &onRestoreInstanceState called. get param: & + param);
super.onRestoreInstanceState(savedInstanceState);
//当指定了android:configChanges=&orientation&后,方向改变时onConfigurationChanged被调用
public void onConfigurationChanged(Configuration newConfig) {
super.onConfigurationChanged(newConfig);
Log.i(TAG, &onConfigurationChanged called.&);
switch (newConfig.orientation) {
case Configuration.ORIENTATION_PORTRAIT:
setContentView(R.layout.orientation_portrait);
case Configuration.ORIENTATION_LANDSCAPE:
setContentView(R.layout.orientation_landscape);
}首先我们需要进入“Settings-&Display”中，将“Auto-rotate Screen”一项选中，表明可以自动根据方向旋转屏幕，然后我们就可以测试流程了，当我们旋转屏幕时，我们发现系统会先将当前Activity销毁，然后重建一个新的：
系统先是调用onSaveInstanceState方法，我们保存了一个临时参数到Bundle对象里面，然后当Activity重建之后我们又成功的取出了这个参数。
为了避免这样销毁重建的过程，我们需要在AndroidMainfest.xml中对OrientationActivity对应的&activity&配置android:configChanges=&orientation&，然后我们再测试一下，我试着做了四次的旋转，打印如下：
可以看到，每次旋转方向时，只有onConfigurationChanged方法被调用，没有了销毁重建的过程。
以下是需要注意的几点：
1.如果&activity&配置了android:screenOrientation属性，则会使android:configChanges=&orientation&失效。
2.模拟器与真机差别很大：模拟器中如果不配置android:configChanges属性或配置值为orientation，切到横屏执行一次销毁-&重建，切到竖屏执行两次。真机均为一次。模拟器中如果配置android:configChanges=&orientation|keyboardHidden&（如果是Android4.0，则是&orientation|keyboardHidden|screenSize&），切竖屏执行一次onConfigurationChanged，切横屏执行两次。真机均为一次。
Activity的生命周期与程序的健壮性有着密不可分的关系，希望朋友们能够认真体会、熟练应用。
参考知识库
* 以上用户言论只代表其个人观点，不代表CSDN网站的观点或立场
访问：2807615次
积分：10337
积分：10337
排名：第1334名
原创：88篇
评论：1559条
博客中的Android系列文章，是在2011年左右完成的，由于近年来Android版本变化等因素，结果可能会有些出入，请大家结合实际情况作参考。Android Activity生命周期都该做哪些事情-学网-中国IT综合门户网站-提供健康,养生,留学,移民,创业,汽车等信息
> 信息中心 >
Android Activity生命周期都该做哪些事情
来源：互联网 发表时间： 21:42:23 责任编辑：鲁晓倩字体：
为了帮助网友解决“Android Activity生命周期都该做哪些事情”相关的问题，学网通过互联网对“Android Activity生命周期都该做哪些事情”相关的解决方案进行了整理,用户详细问题包括:RT,我想知道:Android Activity生命周期都该做哪些事情，具体解决方案如下：解决方案1：而后用户退回当前Activity。5，进入停滞状态.用户退出当前Activity，然后调用onStop方法。2：系统会先调用onRestart方法，即第2步和第4步：系统会调用onResume方法，然后调用onStop方法，再次进入运行状态：系统会先调用onPause方法.当前Activity处于被覆盖状态或者后台不可见状态，结束当前Activity，然后调用onStart方法.启动Activity、onResume方法：再次调用onCreate方法、onStart方法，再次进入运行状态：系统会调用onPause方法，自身退居后台，最后调用onDestory方法，进入运行状态：系统会先调用onCreate方法，最后调用onResume方法.当前Activity被其他Activity覆盖其上或被锁屏。3，暂停当前Activity的执行。6，然后调用onStart方法.当前Activity转到新的Activity界面或按Home键回到主屏：系统先调用onPause方法，最后调用onResume。4.用户后退回到此Activity，Activity进入运行状态。7，杀死当前Activity.当前Activity由被覆盖状态回到前台或解锁屏，系统内存不足1解决方案2：
显示创建，互动（传输数据），隐藏
1个回答1个回答1个回答1个回答1个回答1个回答1个回答1个回答1个回答
相关文章：
最新添加资讯
24小时热门资讯
Copyright © 2004- All Rights Reserved. 学网 版权所有
京ICP备号-1 京公网安备02号Icansoft 的BLOG
用户名：Icansoft
文章数：127
评论数：245
访问量：3884949
注册日期：
阅读量：5863
阅读量：12276
阅读量：403539
阅读量：1092718
51CTO推荐博文
&& Activities是由Activity stack管理的。当一个新的Activity被启动，它就会处于stack的top位置，成为当前运行的Activity。而前一个Activity依然保留在stack里面，当需要调用这个Activity时就会回到stack的top位置成为当前运行的Activity。
&& 一个Activity有4个基本状态：
&& 1. active / running 状态，当Activity处于当前屏幕时；
&& 2. paused 状态，当Activity失去焦点但对用户依然可见时；即是，一个非全屏或者透明的Activity在该Activity的屏幕上面，并成为了当前的焦点。而paused的Activity依然是alive状态的，它保留着所有的状态和成员信息并连接至窗口管理器，但当系统处于极低内存的情况下，仍然可以杀死这个Activity。
&& 3. stopped 状态，当Activity完全被另一个Activity覆盖时；它仍然保留所有的状态和成员信息。但它不再被用户可见，所以它的窗口将被隐藏，当其它地方需要内存，则系统经常会杀死这个Activity。
&& 4. 当Activity是paused或者stopped状态时，系统可以通过要求它结束（调用它的finish()方法）或直接杀死它的进程来将它驱出内存。当它再次为用户可见的时候，它只能完全重新启动并恢复至以前的状态。
&& 怎么来理解Activity的状态及其生命周期呢？引用网友的解释：
&& &由于手机应用的一些特殊性，所以我们需要更多的去关注各个Android Component的运行时生命周期模型。（所谓手机应用的特殊性主要是指这样2点： 1. 手机应用的大多数情况下我们只能在手机上看到一个程序的一个界面 ，用户除了通过程序界面上的功能按钮来在不同的窗体间切换，还可以通过Back键和Home键来返回上一个窗口，而用户使用Back或者Home的时机是非常不确定的，任何时候用户都可以使用Home或Back来强行切换当前的界面。 2. 往往手机上一些特殊的事件发生也会强制的改变当前用户所处的操作状态，例如无论任何情况，在手机来电时，系统都会优先显示电话接听界面。）了解这些Component的生命周期模型一方面是让我们对软件在手机中的运行情况做到心中有数，更重要的，对于程序开发来说，生命周期中的每一个关键事件都会有我们可以覆写于各种Component对应基类型的事件处理方法，了解各Component的生命周期就是让我们在开发程序时明白我们该怎样去编写各种事件的处理代码。&
&& &由于前面已经说到的手机应用的特殊性，一个Activity很可能被强制交换到后台（交换到后台就是指该窗体不再对用户可见，但实际上又还是存在于某个Task中的，比如一个新的Activity压入了当前的Task从而&遮盖&住了当前的Activity，或者用户按了Home键回到桌面，又或者其他重要事件发生导致新的Activity出现在当前Activity之上，比如来电界面），而如果此后用户在一段时间内没有重新查看该窗体（Android通过长按Home键可以选择最近运行的6个程序，或者用户直接再次点击程序的运行图标，如果窗体所在的Task和进程没有被系统销毁，则不用重新加载Process, Task和Task中的Activity， 直接重新显示Task顶部的Activity， 这就称之为重新查看某个程序的窗体），该窗体连同其所在的Task和Process则可能已经被系统自动销毁了，此时如果再次查看该窗体，则要重新执行onCreate事件初始化窗体。而这个时候我们可能希望用户继续上次打开该窗体时的操作状态进行操作，而不是一切从头开始。例如用户在编辑短信时突然来电，接完电话后用户又去做了一些其他的事情，比如保存来电号码到联系人，而没有立即回到短信编辑界面，导致了短信编辑界面被销毁，当用户重新进入短信程序时他可能希望继续上次的编辑。这种情况我们就可以覆写Activity的void onSaveInstanceState(Bundle outState)事件，通过向outState中写入一些我们需要在窗体销毁前保存的状态或信息，这样在窗体重新执行onCreate的时候，则会通过savedInstanceState将之前保存的信息传递进来，此时我们就可以有选择的利用这些信息来初始化窗体，而不是一切从头开始。&
& &下面官方提供的这幅图，描述了Activity生命周期的整个过程：
650) this.width=650;" onclick='window.open("/viewpic.php?refimg=" + this.src)' border="0" alt="activity_lifecycle" src="/attachment/622913.png" />
&&& 可以看到，以上有3个关键的生命周期循环：
&& 1. 一个activity 完整的生命周期 自第一次调用 onCreate(Bundle)开始，直至调用onDestroy()为止。activity在onCreate()中设置所有&全局&状态以完成初始化，而在onDestroy()中释放所有系统资源。比如说，如果activity有一个线程在后台运行以从网络上下载数据，它会以 onCreate()创建那个线程，而以 onDestroy()销毁那个线程。
&& 2. 一个activity的 可视生命周期 自 onStart() 调用开始直到相应的 onStop()调用。在此期间，用户可以在屏幕上看到此activity，尽管它也许并不是位于前台或者正在与用户做交互。在这两个方法中，你可以管控用来向用户显示这个activity的资源。比如说，你可以在onStart() 中注册一个BroadcastReceiver 来监控会影响到你UI的改变，而在onStop() 中来取消注册，这时用户是无法看到你的程序显示的内容的。onStart() 和 onStop() 方法可以随着应用程序是否为用户可见而被多次调用。
&& 3. 一个activity的 前台生命周期 自 onResume() 调用起，至相应的 onPause()调用为止。在此期间，activity位于前台最上面并与用户进行交互。activity会经常在暂停和恢复之间进行状态转换──比如说当设备转入休眠状态或有新的activity启动时，将调用onPause() 方法。当activity获得结果或者接收到新的intent的时候会调用onResume() 方法。因此，在这两个方法中的代码应当是轻量级的。
&& 当一个activity从这个状态转变到另一个状态时，它被以下列protected方法所通知：
public&class&Activity&extends&ApplicationContext&{&&&&&&protected&void&onCreate(Bundle&savedInstanceState);&&&&&&&protected&void&onStart();&&&&&&&protected&void&onRestart();&&&&&&&protected&void&onResume();&&&&&&&protected&void&onPause();&&&&&&&protected&void&onStop();&&&&&&&protected&void&onDestroy();&}&
&& &我们可以重载所有这些方法以在状态改变时进行合适的工作。所有的activity都必须实现 onCreate() 用以当对象第一次实例化时进行初始化设置。很多activity会实现 onPause()以提交数据变化或准备停止与用户的交互。
&& 要注意的是，onPause()，onStop()，onDestory()这3个方法是可以被系统直接kill的，当系统内存不足的时候。而平常从一个activity转向/回到另一个activity时，当新activity是full screen（弹出窗口，例如AlertDialog是不算的）的时候就会call 前一个activity的onPause()，然后call onStop()，而无论onPause或者onStop，都有可能被kill，所以一般在onPause就会执行savedata操作将所有持久性数据（比如用户的编辑结果）写入存储之中。
&& 现在我们来看看两个activity在同一个进程内的调用情况：
&& 1. 调用当前activity的 onPause() 方法。
&& 2. 接着调用新启动activity的onCreate()、 onStart()和onResume()方法。
&& 3. 然后，如果启动的activity不再于屏幕上可见，则调用它的onStop()方法。
& 以下我使用Logcat记录下来的Activity调用过程中的方法调用顺序：
& 1. 点击按钮去启动 Activity1，就会看到
05-08&09:39:48.389:&DEBUG/Activity1(313):&onCreate&&&Activity&1&05-08&09:39:48.399:&DEBUG/Activity1(313):&onStart&&&&Activity&1&05-08&09:39:48.399:&DEBUG/Activity1(313):&onResume&&&Activity&1&
&& 这说明一般Activity的启动顺序是onCreate -& onStart -& onResume
& 2. 点击back返回键后
05-08&09:40:04.129:&DEBUG/Activity1(313):&onPause&&&&Activity&1&05-08&09:40:04.628:&DEBUG/Activity1(313):&onStop&&&&&Activity&1&05-08&09:40:04.659:&DEBUG/Activity1(313):&onDestory&&Activity&1&
&& 退出当前Activity时，onPause -& onStop -& onDestory
& 3. 再次启动Activity
05-08&09:40:18.249:&DEBUG/Activity1(313):&onCreate&&&Activity&1&05-08&09:40:18.249:&DEBUG/Activity1(313):&onStart&&&&Activity&1&05-08&09:40:18.259:&DEBUG/Activity1(313):&onResume&&&Activity&1&
&&和一般启动的顺序是一样的
& 4. 从Activity1启动Acitivity2
05-08&09:40:25.477:&DEBUG/Activity1(313):&onPause&&&&Activity&1&05-08&09:40:25.687:&DEBUG/Activity2(313):&onCreate&&&Activity&2&05-08&09:40:25.687:&DEBUG/Activity2(313):&onStart&&&&Activity&2&05-08&09:40:25.719:&DEBUG/Activity2(313):&onResume&&&Activity&2&05-08&09:40:26.277:&DEBUG/Activity1(313):&onStop&&&&&Activity&1&
&&&Activity1.onPause -& Activity2.onCreate -& Activity2.onStart -& Activity2.onResume -&Activity1.onStop
& 5. 点击Home键回到桌面
05-08&09:40:31.777:&DEBUG/Activity2(313):&onPause&&&&Activity&2&05-08&09:40:32.658:&DEBUG/Activity2(313):&onStop&&&&&Activity&2&
&&Activity2.onPause - & Activity2.onStop
& 6. 回到原来的程序
05-08&09:40:50.429:&INFO/ActivityManager(58):&Starting&activity:&Intent&...&05-08&09:40:50.649:&DEBUG/Activity2(313):&onRestart&&Activity&2&05-08&09:40:50.649:&DEBUG/Activity2(313):&onStart&&&&Activity&2&05-08&09:40:50.769:&DEBUG/Activity2(313):&onResume&&&Activity&2&
&&Activity2.onRestart -& Activity2.onStart -& Activity2.onResume
& 7. 点击comfirm, setResult(RESULT_OK)，Activity2.finish()，返回到Activity1
05-08&09:41:04.928:&DEBUG/Activity2(313):&onPause&&&&Activity&2&05-08&09:41:04.988:&DEBUG/Activity1(313):&onRestart&&Activity&1&05-08&09:41:04.998:&DEBUG/Activity1(313):&onStart&&&&Activity&1&05-08&09:41:04.998:&DEBUG/Activity1(313):&onResume&&&Activity&1&05-08&09:41:05.419:&DEBUG/Activity2(313):&onStop&&&&&Activity&2&05-08&09:41:05.469:&DEBUG/Activity2(313):&onDestory&&Activity&2&
&&Activity2.onPause - & Activity1.onRestart - & Activity1.onStart - & Activity1.onResume - & Activity2.onStop
&& 8. 点击back返回键后
05-08&09:41:51.868:&DEBUG/Activity1(313):&onPause&&&&Activity&1&05-08&09:41:52.428:&DEBUG/Activity1(313):&onStop&&&&&Activity&1&05-08&09:41:52.468:&DEBUG/Activity1(313):&onDestory&&Activity&1&
&&Activity1 退出：onPause -& onStop -& onDestory
保存activity状态
&& 保存activity状态，是为了方便用户重新打开程序时，能够回到上次离开时的状态。这里面涉及到的方法有：
&& protected void onSaveInstanceState (Bundle outState)
&& protected void onRestoreInstanceState (Bundle savedInstanceState)
&& 当一个Activity被kill之前，它可以调用onSaveInstanceState()来保存当前activity的状态信息，它会将一个以名称-值对方式记录了activity动态状态的Bundle对象传递给该方法。当activity再次启动时，这个Bundle会传递给onCreate()方法和随着onStart()方法调用的onRestoreInstanceState()。这两个方法的内容一般是把要临时保存的数据放到Bundle里面，或者从里面拿出来。
&& 要注意的是，onSaveInstanceState() 和 onRestoreInstanceState() 并不是生命周期方法。它们并不是总会被调用。比如说，Android会在activity易于被系统销毁之前调用 onSaveInstanceState()，但用户动作（比如按下了BACK键）造成的销毁则不调用。在这种情况下，用户没打算再次回到这个activity，所以没有保存状态的必要。因为onSaveInstanceState()不是总被调用，所以你应该只用它来为activity保存一些临时的状态，而不能用来保存持久性数据。而是应该用onPause()来达到这个目的：�在onPause()里面调用自定义命名的函数saveState()，在saveState里面保存数据到数据库。
Logcat的使用
1. import android.util.L
2. private static final String TAG = &Activity1&; 设置TAG
3. Log.d(TAG, message);& log记录信息
&&& 其中Log.v() : VERBOSE
&&&&&&&& Log.d() :& DEBUG
&&&&&&&& Log.i() :&& INFO
&&&&&&&& Log.w() : WARN
&&&&&&&& Log.e() : ERROR
&&&& 以上log的级别依次升高，Debug信息应当只存在于开发中，INFO、 WARN、ERROR这3种log将出现在发布版本中。
4. 在Eclipse查看Log:
&&&& 在菜单Window-& Show View选择other，在弹出的窗口中选择Android里面的LogCat，ok，就会看到LogCat窗口，在Filter那里可以输入过滤的词语，一般是输入TAG的内容，这样子可以直接看到有关这个TAG的Log。本文出自 “” 博客，请务必保留此出处
了这篇文章
类别：┆阅读(0)┆评论(0)
本文收录至博客专题：《》