生命周期实践总结,快速掌握activity的生命周期
分类:web前端

什么是Activity        首先,Activity是Android系统中的四大组件之生龙活虎,能够用来呈现View。Activity是多少个与用记人机联作的连串模块,大约全数的Activity都以和客户实行交互作用的,可是假若如此就会说Activity主假使用来显示View就不太准确了。

Android四大组件之Activity

Activity / Fragment 的生命周期是每一个 Android 开采者最最幼功的知识点。所以特意有供给本人打理生机勃勃番。总看外人博客和书上的死知识,还不比本身动手实施,然后输出要影像深入,领悟通透到底。

activity的生命周期不管是在面试依然在职业中大家都会日常遇上,那本来也是非常底子的,功底也很入眼哦,学会activity的生命周期对大家未来开拓越来越硬朗的主次会有一点都不小帮扶。上面来看一下Activity生命周期图:

       在浓郁摸底Activity以前,我们先要知道一下MVC设计情势,在JAVAEE 中MVC设计格局已经很精湛了,何况分的也正如清晰了,可是在Android中,好几人对MVC在Android开辟中的应用不是很明亮,下边作者就先来介绍一下MVC在Android开辟中的应用:

风姿浪漫、Activity的生命周期

Activity是Android的第四次全国代表大会组件之风姿浪漫,可以说是android四大组件中最重大的零件之生机勃勃。它承担了作者们的分界面显示,实际付出中大家经过setContentView(安德拉.layout.id卡塔尔设置界面显示的视图。在Android的门类布局划虚构计中,Activity就一定于MVC设计情势中的View层。在Android的四大组件设计中,为了便利开荒者进行支付应用,Android的开荒者对四大组件通过生命周期进行管制,大家只必要世襲Activity进行重写这一个生命周期来保管和客体使用Activity。 
下边大家来合营探问Android官方文档上提供的Activity的生命周期图: 
图片 1

因而那张图开掘,Activity生命周期的主线是:onCreate(卡塔尔(قطر‎——>onStart(卡塔尔(قطر‎——>onResume(卡塔尔国——>onPause(State of Qatar——>onStop(卡塔尔——>onDestroy(State of Qatar这两个流程主线。下边来解析下这多个生命周期的办法。 
1、创建Activity 
为了创立三个activity,大家必需成立贰个Activity的子类,在大家的自定义子类中,大家要求落到实处这么些回调方法,举例activity的create、stop、resume、destroy。方法的简要介绍:

  • onCreate()方法
    这一个方法大家必须完毕,当大家成立一个activity的时候,系统会调用那么些办法。主要的是,大家亟须透过setContentView(卡塔尔(قطر‎来设定activity的突显视图。(不可以看到)
  • onStart()方法
    在大家创造了视图之后调用,在向顾客显示以前调用。然后调用onResume方法。(不可以见到)
  • onResume()方法: 
    onResume方法是activity举行可知状态,能够与客商进行相互影响。(可以预知可用)
  • onPause()方法
    当大家间隔这一个activity时候系统调用这几个措施。注意:它不代表activity被覆灭(destroy卡塔尔。暂停状态,记得时辰候打游戏,按暂停,游戏分界面就能甘休不动,属于可知状态,不过不能够用,其实原理基本临近。(可以预知但不可用)
  • onStop()方法
    停下状态,当四个activity被另八个activity完全覆盖的时候,它依旧保留着新闻,不过已经对客户不可以知道。(不可以看到)
  • onDestroy()方法
    那时候activity已经被消亡,activity至此生命周期完全竣事。(销毁)

通过地方的流程解析,从与顾客人机联作的角度来讲,Activity的动静分为不可以看到、可以知道可用、可知不可用、销毁。从android官方提供的文书档案来看,生命周期的四个级次:

  • 完整生命周期(entire life)
    activity的豆蔻梢头体化生命周期从onCreate(卡塔尔国方法到onDestroy(卡塔尔国方法。在付出中大家在onCreate方法中张开一些局地开端化的操作,举例控件的早先化和安装控件的监听操作。比方:借使我们有个线程在后台下载数据,它可能在onCreate(卡塔尔(قطر‎方法中开创,在onDestroy(卡塔尔国方法中开展销毁。

  • 可视生命周期(visible life)
    可视化的生命周期从onStart(卡塔尔国方法到onStop(卡塔尔方法,这段生命周期内,客商可以在荧屏上看见此activity。举个例子:当叁个新的activity运营了,那些activity就不在显示了。在此段生命周期内,你能够管理控制你须求向客商显示的财富。举例:你能够在onStart(卡塔尔国方法中注册广播选用者(布罗兹castReceiver),在onStop(卡塔尔方法中撤销注册这么些广播。

  • 前台湾学子命周期(foreground life)
    前台湾学子命周期,此段生命周期顾客能够望见人机联作。这段生命周期从onResume(卡塔尔方法到onPause(卡塔尔(قطر‎方法。在此段生命周期内,这一个activity在具备的activities的前头。当以此装置步向到休眠状态或当一个会话框现身的时候调用onPause(卡塔尔国方法。由于在这里期间的生命周期切换特别频仍,所以在这里段生命周期内部管理理的逻辑管理代码要轻量级,防止来回切换让客商等待时间太久。

在实际上的付出中,大家依据activity的生命周期来贯彻大家的逻辑管理。平时在支付中,在onCreate(卡塔尔(قطر‎方法中开展局部变量的初步化专门的工作,包罗变量的最早化、控件的最早化、控件设置监听等。当三个activity由于遗失主旨时再也重新拿到关节调用onResume方法。在onResume(卡塔尔国方法中我们得以管理部分诸如分界面包车型大巴立异操作。

下边大家因而实例来表达:

public class MainActivity extends Activity {
    private static final String TAG = "ActivityLife";
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        Log.d(TAG,"onCreate");
    }

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

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

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

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

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

(1)、运维activity,查看日志文件:
09-01 14:32:05.850 ﹕ onCreate
09-01 14:32:05.850 ﹕ onStart
09-01 14:32:05.850 ﹕ onResume
通过地点的措施解析,我们运转activity,activity获取关节展以往我们的先头。
(2)、通过按键进行activity的跳转,可是尚未finish(卡塔尔(قطر‎:
09-01 15:03:59.590 ﹕ onCreate
09-01 15:03:59.590 ﹕ onStart
09-01 15:03:59.590 ﹕ onResume
09-01 15:04:23.546 ﹕ onPause
09-01 15:04:23.550 ﹕ SecondActivity:onCreate
09-01 15:04:23.550 ﹕ SecondActivity:onStart
09-01 15:04:23.550 ﹕ SecondActivity:onResume
09-01 15:04:24.130 ﹕ onStop
透过分析发掘,大家的mainActivity在SecondActivity分界面获取到关键后实行的onStop(卡塔尔国方法。分界面失去大旨后,OnPause(State of Qatar方法后。当我们实践finish方法后,就能够在onStop方法试行后进行onDesdroy方法。
(3)、按Home键,实行各类
09-01 15:15:04.262 ﹕ onPause
09-01 15:15:04.942 ﹕ onStop
(4)、横竖屏切换,也正是activity举行双重成立。所以注解周期会走平常创设的流水生产线,日常在实际付出中,大家透过设定android:screenOrientation属性来安装是不是允许横竖屏切换。

  • Activity 生命周期
    • 健康境况下的生命周期剖判
    • 老大状态下的生命周期
  • Fragment
    • 普通的 Fragment
    • ViewPager 中的 Fragment
  • 运转情势
    • Activity 的各个运转格局
    • 切实进行
  • 参照文书档案

图片 2

       M(Model 模型卡塔尔(قطر‎:Model是应用程序的重头戏部分,全体的工作逻辑都应该写在这里边,在Android中Model层与JavaEE中的变化非常小,如:对数据库的操作,对互联网等的操作都放在该层(但不是说它们都位居同三个包中,可以分开放,但它们统称为Model层)。
       V(View 视图):是应用程序中担当生成客户分界面包车型客车部分,也是在全体MVC结构中客户唯黄金时代能够见见的少年老成层,采纳客户输入,显示管理结果;在Android应用中日常采纳XML文件Reade分界面包车型客车陈说,使用的时候能够丰盛方便的引进,当然也足以动用JavaScript+Html等艺术作为View。
       C(Controller调整层)android的调控层的职分将要落在广大的activity的肩上了,所以在此边将在提议我们不要在activity中写太多的代码,尽量能过activity交割Model业务逻辑层管理。

二、Activity的使用

1、首先在manifest配置文件中张开宣示:在application节点下增多activity节点配置。

<manifest ... >
 <application ... >
    <activity android:name=".ExampleActivity" />
    ...
 </application ... >
 ...
</manifest >

activity子节点下面有众多品质配置这几个activity,这么多属性中独有android:name是唯后生可畏一定要安装的,它规定了咱们的activity是哪位类。所以若是接受发表了,就不要去改造这些名称,不然会唤起一同利用bug。越来越多的习性配置参照自家的那篇博客。
2、使用intent filter
经过应用intent-filter能够证明这一个组件的职业方式。我们了然,当大家创设三个运用的时候,系统会自行给大家创制好一个主activity的配置。如下:

<activity android:name=".ExampleActivity" android:icon="@drawable/app_icon">
<intent-filter>
    <action android:name="android.intent.action.MAIN" />
    <category android:name="android.intent.category.LAUNCHER" />
</intent-filter>
</activity>

在此段配置中,我们开采节点配置的main,表达那是大家应用程序的进口。的属性值为LAUNCHE悍马H2标志这是应用程序的开发银行分界面。即使您希图你的应用只供本身调用不容许其余应用程序使用,你无需设置越多的activity,只要设置二个activity具有main的动作和Launcher的归类就足以。然后,要是您指望你的activity能够响应分化选择发送的intent,你一定要为您的activity定义额外的intent-filter项。举个例子:为你全体响应的各样,你不得不包含一个,并安装它的和因素或然成分节点,这一个要素识别intent的品类并响应。

Activity 生命周期

为了便利掌握,笔者差不离的写了一个德姆o,不理解Activity周期的情侣们,能够亲手施行一下,大家鲁人持竿作者的手续来。

       好了,在介绍过Android应用开采中的MVC布局后,大家就可以很猛烈的知道,在Android中Activity首假诺用来做决定的,它能够接纳要显得的View,也足以从View中获取数据然后把数量传给Model层举行拍卖,末了再来突显出处理结果。

三、Activity的启动

在android系统中,我们通过Intent(意图)实行数量的传递或开展activity的跳转。在android系统中设有二种运维形式。 
1、呈现运维
何为展现运转,正是在创制Intent的时钦赐要开动的activity的类。所在此以前提是我们早已知晓Activity的类名称,那就使用在我们在开采app中进行activity的跳转。

Intent intent = new Intent(MainActivity.this,SecondActivity.class);
startActivity(intent);

2、隐式运行
android系统给咱们提供了好些个服务,如打电话、发短信。可是在大家的运用中大家不知器具体的activity类名称,那个时候大家就必要接纳隐式的activity运转方法。

//打电话
Intent intent = new Intent(Intent.ACTION_DIAL, Uri.parse("tel:555-2368"));
startActivity(intent);

//发短信
Intent intent=new Intent();
intent.setAction("android.intent.action.SEND");
intent.setData(Uri.parse("mms:110"));
intent.addCategory(Intent.CATEGORY_DEFAULT);
startActivity(intent);

//打开网页
Intent intent=new Intent();
intent.setAction(Intent.ACTION_VIEW);
intent.setData(Uri.parse("http://www.baidu.com"));
startActivity(intent);

正规情形下的生命周期分析

图片 3

  1. 本着叁个一定的 Activity ,第三回开发银行,回调如下:onCreate —-> onStart —-> onResume

Log 日志
D/KLog: (MainActivity.java:19) onCreate
D/KLog: (MainActivity.java:44) onStart
D/KLog: (MainActivity.java:62) onResume

  1. 切换回到桌面的时候,回调如下:onPause —-> onStop

Log 日志
D/KLog: (MainActivity.java:50) onPause
D/KLog: (MainActivity.java:68) onStop

  1. Back 键退出的话,最终会 onDestroy

  2. 运营一个新的 Activity , 大家看看八个 Activity 的生命周期:

Log 日志
D/KLog: (MainActivity.java:50) onPause
D/KLog: (OtherActivity.java:25) onCreate
D/KLog: (OtherActivity.java:31) onStart
D/KLog: (OtherActivity.java:49) onResume
D/KLog: (MainActivity.java:68) onStop
能够获取顺序是:onPause(A) —-> onCreate(B) —-> onStart(B) —-> onResume(B) —-> onStop(A)

  1. 本条时候大家 Back 回到第一个 Activity 时产生的回调:

Log 日志
D/KLog: (OtherActivity.java:37) onPause
D/KLog: (MainActivity.java:56) onRestart
D/KLog: (MainActivity.java:44) onStart
D/KLog: (MainActivity.java:62) onResume
D/KLog: (OtherActivity.java:55) onStop
D/KLog: (OtherActivity.java:61) onDestroy
能够博得顺序是: onPause(B) —-> onRestart(A) —-> onStart(A) —-> onResume(A) —-> onStop(B) —-> onDestroy(B)

  1. 若是自己在 B Activity 中的 onCreate 回调中一直 finish()

Log 日志
D/KLog: (MainActivity.java:50) onPause
D/KLog: (OtherActivity.java:25) onCreate
D/KLog: (MainActivity.java:62) onResume
D/KLog: (OtherActivity.java:62) onDestroy
我们开掘 B Activity 只会试行 onCreateonDestroy

  1. 接下去大家运维多个非常的 Activity (半透明大概对话框样式)到关闭它:

Log 日志
D/MainActivity: onPause
D/DialogActivity: onCreate
D/DialogActivity: onStart
D/DialogActivity: onResume
D/DialogActivity: onPause
D/MainActivity: onResume
D/DialogActivity: onStop
D/DialogActivity: onDestroy

在正常使用应用的过程中,前台 Activity 有时会被其他导致 Activity 暂停的可视组件阻挡。 例如,当半透明 Activity 打开时(比如对话框样式中的 Activity ),上一个 Activity 会暂停。 只要 Activity 仍然部分可见但目前又未处于焦点之中,它会一直暂停。

图片 4

<div class="tip">
难题:假如是开发银行一个惯常的 Dialog ,Activity 的会奉行 onPause 吗?
</div>

答案是不会的,我们得以如此了解,普通的 dialog 是附属在本 Activity 的,相当于是二个完全,所以它本人的关键也是归属 Activity 的。故不会调用 onPause 。

第一步:新建四个Android工程,笔者那边命名叫MainActivity.再次创下造三个OtherActivity继承activity。

Activity生命周期 接下去大家就一路来看一下Activity的生命周期,为何要看那个吧?作者想学过servlet的童鞋都知情,大家马上在读书servlet的时候也是从生命周期早先的,首先知道诉求的相继,然后知道怎么管理诉求的。唯有这样咱们技艺在急需的时候做一些连锁的政工。
 android的就学也是那样,Activity是android中最根本的,平常景观下都代表叁个分界面,那样,大家只要急需开展什么样管理都亟待在activity上开展拍卖。上面大家来看一下具体的代码。
 1)先建二个品种吧,名称就随意啦。Activity也无论,反正本人看得懂就OK了。
 作者建了一个布局如图:

四、Activity的起步形式

android系统中对activity的运维形式设立了两种运行格局,分别是:standard、singleTop、singleTask、singleInstance那八种运营格局。在念书activity的开发银行格局以前,大家先精晓下android中的职务栈的定义。假如大家有早晚数据构造幼功,聊到‘栈’就清楚它的风味:先进后出。知道那一个后,大家在说android中是何等安排众多activity——通过职务栈来‘装’activity。如下图: 
图片 5

通过那张图,我们得以看来android系统将activity依据前后相继顺序放入栈中进行拘押。当我们点击再次来到键或实行finish方法正是从栈中退出activity。
在事实上开拓中,我们平日会凌驾这种景观,大家从activity1——>activity2,然后实践完activity2——>activity1这种循环跳转,大家就能有这种可疑,这里的activity1三番五次使用,系统是重复创造的activity1的实例依旧复用已经创办存在的实例呢?这里就关系到我们的activity的运行方式涉及。下边大家详细说说这三种运行格局:

  • standard(默许的格局卡塔尔
    在创建多个activity的时候,系统默许的开发银行格局。在此种运维方式下,每一遍运营多个activity就创立叁个实例放到任务栈中。所以我们对于activity不执行finish方法,就能设有五个activity的实例。
  • singleTop(单栈顶格局)
    只要贰个activity实例已经存在当前职务栈的最上端,系统经过onNewIntent方法将intent发送到那么些实例,并非成立一个新的实例。
  • singleTask(单职务形式)
    倘若二个activity已经在职分栈中存在,大家重新运转该activity就不要求再一次成立实例。系统会将该activity实例上边的activity实例施行出栈操作,将此activity推至栈顶。
  • singleInstance(单例形式)
    假诺选拔1的职务栈中成立了MainActivity实例,假设使用2也要激活MainActivity,则无需创设,两施用分享该Activity实例;

讲完了基本概念,大家因此轻易的实例证实下: 
本身使用三个activity,使她们之间互相跳转。先来看下代码。
MainActivity代码:

 protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.activity_main);
    btn_go = (Button)findViewById(R.id.btn_go);
    btn_go.setOnClickListener(new View.OnClickListener() {
        @Override
        public void onClick(View v) {
            Intent intent = new Intent(MainActivity.this,SecondActivity.class);
            startActivity(intent);
        }
    });
}

SecondActivity代码:

    protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.secondlayout);
    Button btn_goMain = (Button)findViewById(R.id.btn_goMain);
    btn_goMain.setOnClickListener(new View.OnClickListener() {
        @Override
        public void onClick(View v) {
            Intent intent = new Intent(SecondActivity.this,MainActivity.class);
            startActivity(intent);
        }
    });
}

(1)、将八个activity的启航航空模型型式设置为standard情势。通过android:launchMode实行设置 
,如下:

 <application
    android:allowBackup="true"
    android:icon="@mipmap/ic_launcher"
    android:label="@string/app_name"
    android:theme="@style/AppTheme" >
    <activity
        android:name=".MainActivity"
        android:label="@string/app_name"
        android:launchMode="standard">
        <intent-filter>
            <action android:name="android.intent.action.MAIN" />

            <category android:name="android.intent.category.LAUNCHER" />
        </intent-filter>
    </activity>
    <activity android:name=".SecondActivity"
        android:launchMode="standard"/>
</application>

咱俩先布局多少个activity的实例,放到职责栈中。操作顺序: 
MainActivity->SecondActivity->MainActivity。 
咱俩由此截图看看大家按一遍重临键退出应用:

standard模式

因此截图我们看以观察,我们点击了频仍才脱离应用,那表明我们在跳转的长河中新建了三个activity的实例。 
图片 6

(2)singleTop模式, 
这种格局下,举个例子大家栈中有A->B->C->D,那时D在栈的顶端,大家重新走入D,要是使用standard形式,则栈中就有A->B->C->D->D,singleTop情势下就不会重新制造新的实例。A->B->C->D 
我们将SecondActivity设置为singleTop格局,查看运营截图: 
图片 7

(3)singleTask模式: 
一向上运转截图,大家设置MainActivity为singleTask,大家点击退出,直接退出应用。 
图片 8

老大意况下的生命周期

图片 9

onSaveInstanceState 方法只会冒出在 Activity 被百般终止的景观下,它的调用时机是在 onStop 之前,它和 onPause 方法未有既定的时序关系,大概在它以前,也可能在它以后。当 Activity 被另行成立的时候, onRestoreInstanceState 会被回调,它的调用机遇是 onStart 之后。
系统只会在 Activity 将在被销毁並且有机遇再一次呈现的意况下才会去调用 onSaveInstanceState 方法。
Activity 在相当景况下须求重新创建时,系统会默感觉大家保留当前 Activity 的视图构造,而且在 Activity 重启后为大家过来这个多少,举例文本框中顾客输入的数量、listview 滚动的职位等,这几个 view 相关的场合系统都会默以为我们过来。具体指向某叁个 view 系统能为我们还原哪些数据能够查阅 view 的源码中的 onSaveInstanceStateonRestoreInstanceState 方法。

Demo 代码:

@Override
protected void onSaveInstanceState(Bundle outState) {
    super.onSaveInstanceState(outState);
    KLog.d(getClass().getSimpleName(),"onSaveInstanceState");
    outState.putString(STATE, "test");
}

@Override
protected void onRestoreInstanceState(Bundle savedInstanceState) {
    super.onRestoreInstanceState(savedInstanceState);
    KLog.d(getClass().getSimpleName(),"[onRestoreInstanceState]: " + savedInstanceState.getString(STATE));
}

为了有扶持我们旋转下显示器来丰富终止 Activity :

Log 日志
D/MainActivity: onPause
D/MainActivity: onSaveInstanceState
D/MainActivity: onStop
D/MainActivity: onDestroy
D/MainActivity: onCreate
D/MainActivity: onStart
D/MainActivity: [onRestoreInstanceState]: test
D/MainActivity: onResume

摘自 Android 开垦者艺术索求 一书:

有关保存和恢复生机 View 的档期的顺序构造,系统办事流程是: Activity 卓殊终止, Activity 调用 onSaveInstanceState 去保存数据,然后 Activity 会委托 Windows 去保存数据,接着 Window 再托付它上边的顶层容器去保存数据。顶层容器是多少个 ViewGroup ,平时的话它很只怕是 DectorView ,最终顶层容器再去通告它的子成分保存数据。(那是生龙活虎种委托观念,上层委托下层,父容器委托子成分去处理业务,如 View 的绘图进程,事件分发都以使用相同的沉凝)

源码打印?

图片 10

以上正是有关Activity的中坚学习,招待大家留言沟通。

Fragment

public class MainActivity extends Activity {

这里的名目是不管的,不必追求豆蔻梢头致。
 2)我们看来本人有多个Activity,后边也讲了Activity是四个分界面,那么五个自然便是三个分界面啦。
 看代码以前,我们先来拜会Activity事件的主意,犹如下多少个:

普通的 Fragment

图片 11

图片 12

从图能够看来,Fragment 生命周期一大半的景色与 Activity 相像,特殊的是

  • onAttach() —— 当 Fragment 被参预到 Activity 时调用(在这里个措施中得以获取外省的 Activity 卡塔尔国.
  • onCreateView() —— 当 Activity 要赢得 Fragment 的 Layout 时,调用此措施,Fragment 在中间成立和睦的 Layout (分界面卡塔尔(قطر‎。
  • onActivityCreated() —— 当 Activity 的 onCreated(卡塔尔方法再次来到后调用此措施
  • onDestroyView() —— 当 Fragment 中的视图被移除的时候,调用那么些办法。
  • onDetach() —— 当 Fragment 和 Activity 分离的时候,调用那一个措施。

/** Called when the activity is first created. */

public void onCreate(Bundle savedInstanceState) ; 
public void onDestroy(); 
public void onPause(); 
public void onRestart(); 
public void onResume(); 
public void onStart(); 
public void onStop();

ViewPager 中的 Fragment

我们开拓中平日会用到 ViewPager + Fragment 组合的格局来达成一定的急需。自个儿 Fragment 生命周期就比 Activity 要复杂超多,当它在 ViewPager 中又是怎么回调呢?

自家先给 ViewPager 插手七个 Fragment:

viewPager = (ViewPager) findViewById(R.id.viewpager);
fragmentList.add(new OneTextFragment());
fragmentList.add(new TwoTextFragment());
fragmentList.add(new ThreeTextFragment());
viewPager.setAdapter(new FtAdapter(getSupportFragmentManager(), fragmentList));

启航那个 Activity 的日记如下:

D/ViewPagerHostActivity: onCreate
D/ViewPagerHostActivity: onStart
D/ViewPagerHostActivity: onResume
D/OneTextFragment: onAttach
D/OneTextFragment: onCreate
D/TwoTextFragment: onAttach
D/TwoTextFragment: onCreate
D/TwoTextFragment: onActivityCreated
D/OneTextFragment: onActivityCreated
D/OneTextFragment: onStart
D/OneTextFragment: onResume
D/TwoTextFragment: onStart
D/TwoTextFragment: onResume

我们发掘运转后,有八个 Fragment(one,two卡塔尔(قطر‎被创立,为啥会创设几个?那些难题大家留着前边说。

当 Activity 步入后台:

D/ViewPagerHostActivity: onPause
D/ViewPagerHostActivity: onSaveInstanceState
D/TwoTextFragment: onStop
D/OneTextFragment: onStop
D/ViewPagerHostActivity: onStop

当 Activity 重临前台:

D/ViewPagerHostActivity: onRestart
D/TwoTextFragment: onStart
D/OneTextFragment: onStart
D/ViewPagerHostActivity: onStart
D/ViewPagerHostActivity: onResume
D/TwoTextFragment: onResume
D/OneTextFragment: onResume

当 Activity 销毁:

D/ViewPagerHostActivity: onPause
D/TwoTextFragment: onStop
D/OneTextFragment: onStop
D/ViewPagerHostActivity: onStop
D/TwoTextFragment: onDestroyView
D/TwoTextFragment: onDestroy
D/TwoTextFragment: onDetach
D/OneTextFragment: onDestroyView
D/OneTextFragment: onDestroy
D/OneTextFragment: onDetach
D/ViewPagerHostActivity: onDestroy

滑动少年老成页:

D/ThreeTextFragment: onAttach
D/ThreeTextFragment: onCreate
D/ThreeTextFragment: onActivityCreated
D/ThreeTextFragment: onStart
D/ThreeTextFragment: onResume

最近呈现的页面是 TwoTextFragment 然后 ThreeTextFragment 也曾经创建好了。

再滑动风流倜傥页:

D/OneTextFragment: onStop
D/OneTextFragment: onDestroyView

时下展现的页面是 ThreeTextFragment ,咱们发掘 OneTextFragment 已经销毁。

大家能够获取暗许状态下的 ViewPager 会缓存 1 个 Fragment,约等于有三个Fragment 是创制状态。
当大家扩充生机勃勃行代码:

viewPager.setOffscreenPageLimit(2);

当 Activity 创制时的生命周期:

D/ViewPagerHostActivity: onCreate
D/ViewPagerHostActivity: onStart
D/ViewPagerHostActivity: onResume
D/OneTextFragment: onAttach
D/OneTextFragment: onCreate
D/TwoTextFragment: onAttach
D/TwoTextFragment: onCreate
D/ThreeTextFragment: onAttach
D/ThreeTextFragment: onCreate
D/TwoTextFragment: onActivityCreated
D/OneTextFragment: onActivityCreated
D/OneTextFragment: onStart
D/OneTextFragment: onResume
D/TwoTextFragment: onStart
D/TwoTextFragment: onResume
D/ThreeTextFragment: onStart
D/ThreeTextFragment: onResume

八个 Fragment 都创制好了,何况左右切换不会走其余生命周期(纵然是废话)。

setOffscreenPageLimit 源码:

public void setOffscreenPageLimit(int limit) {
    if (limit < DEFAULT_OFFSCREEN_PAGES) {
        Log.w(TAG, "Requested offscreen page limit " + limit + " too small; defaulting to " +
                DEFAULT_OFFSCREEN_PAGES);
        limit = DEFAULT_OFFSCREEN_PAGES;
    }
    if (limit != mOffscreenPageLimit) {
        mOffscreenPageLimit = limit;
        populate();
    }
}

由此源码大家得以领略,ViewPager 的缓存的默许值和最小值是 1

@Override

   这么些办法,我们看方法名大概就足以猜到那多少个方式是在怎样时候调用的了。但的确要领会却不是那么粗略的。
 下边先导大家的宗旨,看代码啦。
 首先看一下strings.xml,这里定义了大家必要体现的字符串。

开始格局

public void onCreate(Bundle savedInstanceState) {

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

Activity 的两种运营格局

  • Standard:标准方式,风度翩翩调用 startActivity(State of Qatar方法就能够生出叁个新的实例。

  • SingleTop: 来了 intent, 每便都创建新的实例,仅二个不等:当栈顶的activity 刚好正是该activity的实例(即必要创立的实例State of Qatar时,不再次创下立新实例。那化解了栈顶复用难题

  • SingleTask: 来了 intent 后,检查栈中是或不是存在该 activity的实例,假诺存在就把 intent 发送给它,不然就创设二个新的该activity的实例,放入二个新的 task 栈的栈底。肯定坐落于三个 task 的栈底,何况栈中只可以有它四个该 activity 实例,但允许任何 activity 参预该栈。消逝了在二个 task 中国共产党享一个activity。

  • SingleInstance: 这一个跟 SingleTask 基本上是均等,只有一个组别:在此个形式下的Activity实例所处的task中,只可以有其风流罗曼蒂克activity实例,不可能有其它的实例。一旦该方式的activity的实例已经存在于有个别栈中,任何利用在激活该activity时都会援用该栈中的实例,解决了三个task共享二个activity。

这个运营方式能够在效力项目清单文件 AndroidManifest.xml 中展开设置,中的 launchMode 属性。

super.onCreate(savedInstanceState);

  前边八个细枝末节了,只是创设后并未张开修正。
 大家来看一下界面包车型地铁XML:

切切实实施行

  • SingleTop 栈顶复用方式
<activity android:name=".dLaunchChapter.OneActivity"
    android:launchMode="singleTop"/>

大家在项目清单里先给 OneActivity 运营格局设置为 singleTop ,然后代码运维活动的相继为 One --> One,一再点击多次,然后我们看看栈内部原因况。

adb 命令 :dumpsys activity | grep -i run

root@vbox86p:/ # dumpsys activity | grep -i run
    Running activities (most recent first):
        Run #1: ActivityRecord{23e3b5b u0 com.hugo.demo.activitydemo/.dLaunchChapter.OneActivity t595}
        Run #0: ActivityRecord{1a2c6f3 u0 com.hugo.demo.activitydemo/.LaunchActivity t595}

该运行格局下同一时候 OneActivity 在栈顶所以不会创制新的实例,其生命周期调用 onPause —-> onNewIntent —-> onResume

  • SingleTask 栈内复用形式

改良 OneActivity 的启航航空模型型式为 SingleTask ,然后大家代码运转的依次为 One —-> Two —-> One,接了下看看栈内部原因况:

One —-> Two 我们记录下当前的 Activity 栈:

Running activities (most recent first):
        Run #2: ActivityRecord{1e8701b7 u0 com.hugo.demo.activitydemo/.dLaunchChapter.TwoActivity t632}
        Run #1: ActivityRecord{39e11719 u0 com.hugo.demo.activitydemo/.dLaunchChapter.OneActivity t632}

接下去大家实施 Two —-> One ,当前 Activity 栈信息:

Running activities (most recent first):
       Run #1: ActivityRecord{39e11719 u0 com.hugo.demo.activitydemo/.dLaunchChapter.OneActivity t632}

当 TwoActivity 运维 OneActivity(SingleTask) 的时候,仓库音讯里只剩余了 OneActivity 何况和第4回内存音讯 39e11719 相像,所以实乃复用了并未新建实例,接下去大家看看 Log 日志,再作证下大家的猜想,看看实际走了怎么生命周期:

D/TwoActivity: onPause
D/OneActivity: onNewIntent
D/OneActivity: onRestart
D/OneActivity: onStart
D/OneActivity: onResume
D/TwoActivity: onStop
D/TwoActivity: onDestroy

果真那时候 OneActivity 未有再度成立,况兼系统把它切换成了栈顶并调用 onNewIntent 方法,同不时间大家开采, SingleTask 暗中认可具备 clearTop 效果,引致TwoActivity 出栈。

<div class="tip">
作者们代码钦赐 OneActivity 的栈,效果照旧长期以来的啊?
</div>

带着难题我们校订下代码,扩张风流罗曼蒂克行:

<activity
    android:name=".dLaunchChapter.OneActivity"
    android:launchMode="singleTask"
    android:taskAffinity="com.hugo.demo.singleTask"/>

接下来大家遵照刚刚顺序 One —-> Two —-> One 运转 Activity ,现在的栈内音讯还只怕会更上次相符呢?

Running activities (most recent first):
        Run #2: ActivityRecord{1bc18519 u0 com.hugo.demo.activitydemo/.dLaunchChapter.OneActivity t636}
        Run #1: ActivityRecord{36e5e368 u0 com.hugo.demo.activitydemo/.dLaunchChapter.TwoActivity t635}

笔者们开掘,纵然是复用了 OneActivity 并且移到了栈顶,然则并不曾消逝TwoActivity 。

原因在于 singleTask 情势受 taskAffinity 影响,TwoActivity 和 OneActivity 所在的 Activity 栈不同。

小结,运转三个 lauchMode 为 singleTask 的 Activity 时有二种情形:

  1. 若系统中存在相通 taskAffinity 值的天职栈 (tacks1 卡塔尔(قطر‎时,会把 task1 从后台调到前台,若实例存在则干掉其上边包车型地铁享有 Activity 并调用 onNewInstance 方法重用,未有该实例则新建一个。
  2. 要否则,新建叁个职务栈,并以此 Activity 作为 root 。
  • SingleInstance 单实例方式

这是风度翩翩种进步的 singleTask 形式,它除了具有 singleTask 情势的富有性格以外,还加强了少数,便是具备此形式的 Activity 只可以单独地坐落职务栈。

<div class="tip">
好了,关于生命周期和运维情势实行+知识点收拾已经完结啦,
十一分推荐大家下载源码本人运行看看 Log 日志,查看源码:Github
,这样能够对那篇作品知识更加深厚。
</div>

setContentView(R.layout.main);

<?xml version="1.0" encoding="utf-8"?> 
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android" 
  android:orientation="vertical" 
  android:layout_width="fill_parent" 
  android:layout_height="fill_parent" 
  > 
  <Button 
    android:layout_width="wrap_content" 
    android:layout_height="wrap_content" 
    android:text="@string/start" 
    android:id="@+id/start" 
    /> 
  <Button 
    android:layout_width="wrap_content" 
    android:layout_height="wrap_content" 
    android:text="@string/stop" 
    android:id="@+id/stop" 
    /> 
</LinearLayout>

参照文书档案

  • Android 开荒方式查究 第豆蔻梢头章
  • 处理Activity生命周期
  • Print the current back stack in the log

System.out.println("MainActivity:----------------onCreate--");

  这里咱们应该大致都得以看得懂啦,特简单的,就七个按键而已,五个是开始另贰个Activity,另二个是甘休当前的Activity。特别简单,假诺这里看不懂,就必要先补充一下android的基本知识啦。
 还也有八个是androidManifest.xml这么些是最要紧的,因为大家用了四个Activity,五个都急需在此开展“注册”,不然将不得动用。

Button button=(Button) this.findViewById(R.id.button);

<?xml version="1.0" encoding="utf-8"?> 
<manifest xmlns:android="http://schemas.android.com/apk/res/android" 
   package="com.shun.android" 
   android:versionCode="1" 
   android:versionName="1.0"> 
  <uses-sdk android:minSdkVersion="7" /> 
 
  <application android:icon="@drawable/icon" android:label="@string/app_name"> 
    <activity android:name=".MainActivity" 
         android:label="@string/app_name"> 
      <intent-filter> 
        <action android:name="android.intent.action.MAIN" /> 
        <category android:name="android.intent.category.LAUNCHER" /> 
      </intent-filter> 
    </activity> 
     
    <activity android:name=".OtherActivity" 
         android:label="@string/other"> 
      <intent-filter> 
        <action android:name="android.intent.action.MAIN" /> 
        <category android:name="android.intent.category.LAUNCHER" /> 
      </intent-filter> 
    </activity> 
 
  </application> 
</manifest>

button.setOnClickListener(new View.OnClickListener() {

 注意,这里的Activity的依次跟你运维的依次有关,笔者那边需求以MainActivity来运营,所以放在OtherActivity前边。
 3)这里大家看完了界面代码,接下去便是我们最重要的代码啦。MainActivity和OtherActivity。大家经过MainActivity来进行运转。点击早先另多个Activity则运维OtherActivity。甘休则对应的休憩当前的Activity。
 下面是MainActivity的代码:

public void onClick(View v) {

package com.shun.android; 
 
import android.app.Activity; 
import android.content.Intent; 
import android.os.Bundle; 
import android.util.Log; 
import android.view.View; 
import android.widget.Button; 
 
public class MainActivity extends Activity { 
  private static final String TAG = "MainActivity"; 
  @Override 
  public void onCreate(Bundle savedInstanceState) { 
    super.onCreate(savedInstanceState); 
    setContentView(R.layout.main); 
     
    Log.i(TAG,"onCreate"); 
     
    Button start = (Button)findViewById(R.id.start); 
    start.setOnClickListener(new View.OnClickListener() { 
       
      public void onClick(View v) { 
        Intent intent = new Intent(MainActivity.this,OtherActivity.class); 
        startActivity(intent); 
        MainActivity.this.finish(); 
      } 
    }); 
     
    Button stop = (Button)findViewById(R.id.stop); 
    stop.setOnClickListener(new View.OnClickListener() { 
       
      public void onClick(View v) { 
        MainActivity.this.finish(); 
      } 
    }); 
     
  } 
   
  protected void onDestroy(){ 
    Log.i(TAG,"onDestroy"); 
    super.onDestroy(); 
  } 
   
  protected void onPause(){ 
    Log.i(TAG,"onPause"); 
    super.onPause(); 
  } 
   
  protected void onRestart(){ 
    Log.i(TAG,"onRestart"); 
    super.onRestart(); 
  } 
   
  protected void onResume(){ 
    Log.i(TAG,"onResume"); 
    super.onResume(); 
  } 
   
  protected void onStart(){ 
    Log.i(TAG,"onStart"); 
    super.onStart(); 
  } 
   
  protected void onStop(){ 
    Log.i(TAG,"onStop"); 
    super.onStop(); 
  } 
}

// TODO Auto-generated method stub

  OtherActivity代码如下:

Intent intent=new Intent(MainActivity.this,OtherActivity.class);

package com.shun.android; 
 
import android.app.Activity; 
import android.content.Intent; 
import android.os.Bundle; 
import android.util.Log; 
import android.view.View; 
import android.widget.Button; 
 
public class OtherActivity extends Activity{ 
 
  private static final String TAG = "OtherActivity"; 
  @Override 
  public void onCreate(Bundle savedInstanceState) { 
    super.onCreate(savedInstanceState); 
    setContentView(R.layout.main); 
     
    Log.i(TAG,"onCreate"); 
     
    Button start = (Button)findViewById(R.id.start); 
    start.setOnClickListener(new View.OnClickListener() { 
       
      public void onClick(View v) { 
        Intent intent = new Intent(OtherActivity.this,MainActivity.class); 
        startActivity(intent); 
        OtherActivity.this.finish(); 
      } 
    }); 
     
    Button stop = (Button)findViewById(R.id.stop); 
    stop.setOnClickListener(new View.OnClickListener() { 
       
      public void onClick(View v) { 
        OtherActivity.this.finish(); 
      } 
    }); 
     
  } 
   
  protected void onDestroy(){ 
    Log.i(TAG,"onDestroy"); 
    super.onDestroy(); 
  } 
   
  protected void onPause(){ 
    Log.i(TAG,"onPause"); 
    super.onPause(); 
  } 
   
  protected void onRestart(){ 
    Log.i(TAG,"onRestart"); 
    super.onRestart(); 
  } 
   
  protected void onResume(){ 
    Log.i(TAG,"onResume"); 
    super.onResume(); 
  } 
   
  protected void onStart(){ 
    Log.i(TAG,"onStart"); 
    super.onStart(); 
  } 
   
  protected void onStop(){ 
    Log.i(TAG,"onStop"); 
    super.onStop(); 
  } 
   
}

startActivity(intent);

  代码没啥好讲的罗,非常的粗略的。主要依旧要理解生命周期。
 下边我们看一下运营的意义:
 当大家进行运转的时候:

}

图片 13

});

它首先运转onCreate,其次是onStart,再来正是onResume。那多个特定,不用犯嘀咕。
 界面如下:

}

图片 14

@Override

此刻大家点击运维另三个Activity看看效果,这里是MainActivity,点击后将会跳转到OtherActivity。
 我们看看效果:

protected void onStart() {

图片 15

super.onStart();

此地曾经跳转到另一个Activity,因为大家用了千篇少年老成律的layout,所以展示的是平等的,只是标题不等同。
    大家来看看它的音信:

// The activity is about to become visible.

图片 16

System.out.println("MainActivity:----------------onStart--");

小编们看出MainActivity会首先暂停,然后再扩充新的Activity的创造进程,创设达成后就调用销毁MainActivity。
 
 我们估摸会困惑,因为自身在MainActivity中把finish写在startActivity后边,肯定是因为那个才在后边调用stop的。首先不是必然的那样快,大家来把finish放到前面来拜望。
 大家把MainActivity中的onCreate中的部分代码修改成上面的:

}

start.setOnClickListener(new View.OnClickListener() { 
       
      public void onClick(View v) { 
        MainActivity.this.finish(); 
        Intent intent = new Intent(MainActivity.this,OtherActivity.class); 
        startActivity(intent); 
      } 
    });

@Override

  这里我们把finish放到前边了,大家再一次运维后能够见见效果:

protected void onResume() {

图片 17

super.onResume();

咱们来看功用是相通的。但为了代码的易读,提议如故放到前边,切合生命周期的调用顺序。
 
 未来大家在OtherActivity中,大家想要回到MainActivity中,如故长期以来运行另多个Activity:

// The activity has become visible (it is now "resumed").

图片 18

System.out.println("MainActivity:----------------onResume--");

此处的调用过程也是均等,首先暂停,创制,最终销毁。
 以往大家平素关门MainActivity有:

}

图片 19

@Override

此地大家看出它首先调用onPause方法,之后才是专门的工作告大器晚成段落和销毁。从今今后间大家猜疑,当产生一个Activity的切换时,都会先调用当前Activity的onPause方法。这里,大家先不说正不得法,接下去看看,实施证美素佳儿切。
 
 4)我们在前方是手动finish了那个Activity,下边大家不收场了,我们看看改良的代码:
 OtherActivity中依旧会调用finish来销毁这么些页面,因为不供给了。
 OtherActivity如下:

protected void onPause() {

Button start = (Button)findViewById(R.id.start); 
    start.setOnClickListener(new View.OnClickListener() { 
       
      public void onClick(View v) { 
        OtherActivity.this.finish(); 
      } 
    }); 
 MainActivity如下:
Button start = (Button)findViewById(R.id.start); 
    start.setOnClickListener(new View.OnClickListener() { 
       
      public void onClick(View v) { 
        Intent intent = new Intent(MainActivity.this,OtherActivity.class); 
        startActivity(intent); 
      } 
    });

super.onPause();

  那样大家就改好了,别之处并没有供给更改。
 大家看看效果,当我们运维MainActivity后,大家点击运营另贰个Activity来运维OtherActivity,我们来拜候消息:

// Another activity is taking focus (this activity is about to be "paused").

图片 20

System.out.println("MainActivity:----------------onPause--");

大家见到它并未调用onDestroy,那表明那些onDestroy是当大家调用finish方法才会调用的。
 上边大家在OtherActivity中式茶食击运转另二个Activity来运转另叁个Activity,注意,这里的“运维”并非当真运行,不是透过startActivity来运营的,只是甘休近日的Activity。
 大家看看音讯:

}

图片 21

@Override

此地大家再点击运行另三个Activity,实际上只是结束当前的OtherActivity。大家看看打字与印刷出来的音讯:

protected void onStop() {

图片 22

super.onStop();

此处大家见到它并非调用MainActivity的onCreate方法,因为MainActivity并不曾被销毁,而只是截至了罢了。当OtherActivity被死灭,要切换的时候,会重复开动MainActivity。那个时候就能够调用onRestart。
 
 5)注意,大家那边以把OtherActivity作为多个整的Activity,就是占全体分界面的。下边大家来看此外风姿罗曼蒂克种情况,即大家运行的是多个对话框。
 我们须要改进androidManifest.xml,改良后如下:

// The activity is no longer visible (it is now "stopped")

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

System.out.println("MainActivity:----------------onStop--");

  只须求校勘OtherActivity的概念就能够,这里我们把它定义成Dialog即对话框类型,它并不会占用整个分界面,而原先的Activity后退到后台运维。
 为了效果的现身说法,大家先把MainActivity中运营另叁个Activity中的finish代码去掉,而把OtherActivity中的启动另三个Activity的代码去掉,留下finish代码。那样就足以看出重复开动的成效。
 去掉后的代码如下:
 MainActivity中的部分代码:

}

Button start = (Button)findViewById(R.id.start); 
    start.setOnClickListener(new View.OnClickListener() { 
       
      public void onClick(View v) { 
        Intent intent = new Intent(MainActivity.this,OtherActivity.class); 
        startActivity(intent); 
      } 
    });

@Override

  OtherActivity中的代码:

protected void onDestroy() {

Button start = (Button)findViewById(R.id.start); 
    start.setOnClickListener(new View.OnClickListener() { 
       
      public void onClick(View v) { 
        OtherActivity.this.finish(); 
      } 
    });

super.onDestroy();

  大家运维后点击运营另四个Activity能够见到:

// The activity is about to be destroyed.

图片 23

System.out.println("MainActivity:----------------onDestroy--");

此处大家看出MainActivity只调用了一个onPause,也正是说它并未停下,只是在后台运维。
 我们看效果:

}

图片 24

}

大家看见主的Activity跑到后边并摇身生机勃勃变半透明的状态,这是它正值后台运营。
 当大家点击运行另贰个Activity,注意,大家这边并不运转另一个Activity,而只是一向截至近日的Activity。
 未来当大家点击运行另一个Activity时,当前的OtherActivity会关闭,而回到原本的MainActivity。
 大家来寻访效果:

源码打字与印刷?

图片 25

public class OtherActivity extends Activity {

而后台的音讯如下:

/** Called when the activity is first created. */

图片 26

@Override

它一贯调用onResume重新上涨MainActivity,并不是重新起动。那是因为MainActivity还在后台运营,大家不须要再另行开动一个。
 
 其实那个生命周期并轻便,难的是每种阶段要驾驭。随着接触的事物更增加,相信对那几个周期的知情会更深的。
 下边给叁个android官方的生命周期的图我们一块念书:

public void onCreate(Bundle savedInstanceState) {

图片 27

super.onCreate(savedInstanceState);

setContentView(R.layout.other);

System.out.println("OtherActivity:----------------onCreate--");

}

@Override

protected void onStart() {

super.onStart();

// The activity is about to become visible.

System.out.println("OtherActivity:----------------onStart--");

}

@Override

protected void onResume() {

super.onResume();

// The activity has become visible (it is now "resumed").

System.out.println("OtherActivity:----------------onResume--");

}

@Override

protected void onPause() {

super.onPause();

// Another activity is taking focus (this activity is about to be "paused").

System.out.println("OtherActivity:----------------onPause--");

}

@Override

protected void onStop() {

super.onStop();

// The activity is no longer visible (it is now "stopped")

System.out.println("OtherActivity:----------------onStop--");

}

@Override

protected void onDestroy() {

super.onDestroy();

// The activity is about to be destroyed.

System.out.println("OtherActivity:----------------onDestroy--");

}

}

其三步:运营上述工程,效果图如下(没什么特别的State of Qatar:

图片 28

主干在Logcat视窗里,我们张开应用时前后相继进行了onCreate(State of Qatar->onStart(State of Qatar->onResume多个法子,看一下LogCat视窗如下:

图片 29

点击go按钮:

图片 30

确定跳转到了 另一个activity分界面,上边让我们看看logcat:

图片 31

当点击go开关后先是执行mainActivity的onPause 然后挨门挨户实行otherActivity的 onCreate(卡塔尔国 onStart()onResume(State of Qatar方法,当一切显示器被另三个activity完全遮挡住了 调用mainActivity的onStop方法.

接下去点击back按键:

图片 32

那一遍先是调用了otherActivity的onPuse方法,失去主题,然后调用mainActivity的onStart onResume 接着正是otherActivity的终止,销毁。

从上边能够见到onCreate方法只调用叁次,当八个activity失去主旨时,也正是不在最前端时调用onPause方法, 当整个activity不可以知道时,也正是一心被另多个activity覆盖时,会调用onStop方法。

下边再让我们看下上面的Activity生命周期图是否就便于精通了,当失去焦点时调用onPause方法,重新拿到主题调用OnResume方法 那三个办法是周旋的。完全被掩瞒调用onStop方法,再次来到前端调用onStart方法。

然后在点击home键验证一下:

图片 33

本文由10bet手机官网发布于web前端,转载请注明出处:生命周期实践总结,快速掌握activity的生命周期

上一篇:wordpress调用当前分类下子分类的方法,WordPress中获取指定分类及其子分类下的文章数目 下一篇:没有了
猜你喜欢
热门排行
精彩图文