什么是生命周期呢？
我们平时在开发软件的时候，就有软件的生命周期。同样的很多事物都有自己的生命周期。一般来说，生命周期不由自己控制。自杀是一个例外，对吧！
先举个例子吧： – 一辆车的生命周期有：被创建—>被购买—->被使用—–>被报废 – 一个人的生命周期：被成为受精卵—->被出生—–>被长大——>被去世
相信这两个例子可以理解吧，虽然举得不太好，是吧！！
而我们的Activity也是有生命周期的：
被创建—->被开始—>被可视—–>被暂停—–>被停止——>被销毁
先不用关心实际是怎么回事，把这文章读完你就知道了，实在不行就看视频吧。
Activity的生命周期
其实前面我们已经使用到了Activity的生命周期方法了，我们常在onCreate方法里头设置内容呢，找到控件之类的操作。
这个方法是被系统回调的，也就是不由我们控制的。学习Activity的生命周期有什么用呢？当然有用，我们先举个例子：
比如说我们前面有这样一个发短信的例子： 它的布局如下:
<?xml version="1.0" encoding="utf-8"?>
<LinearLayout
xmlns:android="https://schemas.android.com/apk/res/android"
xmlns:tools="https://schemas.android.com/tools"
android:layout_width="match_parent"
android:layout_height="match_parent"
android:orientation="vertical"
tools:context=".MainActivity">
<EditText
android:id="@+id/message_content"
android:layout_width="match_parent"
android:layout_height="100dp"
android:hint="请输入短信内容!"
android:inputType="textMultiLine"/>
<Button
android:layout_width="match_parent"
android:layout_height="wrap_content"
android:onClick="sendMsg"
android:text="发送短信!"/>
</LinearLayout>
Activity里头什么都不写，就这样子：
package com.sunofbeaches.activitylifecircledemo;
import android.support.v7.app.AppCompatActivity;
import android.os.Bundle;
public class MainActivity extends AppCompatActivity {
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
}
}
接着 ，把应用部署到模拟器上—->再输入一些内容—->点击返回键—–>再打开应用
我们很惊讶地发现，我们再次打开这个应用的时候，上次写的东西已经没有了。
如果想要用户体验好一点，是不是要把数据保存起来呢？那什么时候保存，当然是在销毁之前保存吧。
那被销毁就是一个生命周期方法啦！
这个onDetory是怎么回事呢？我们后面再对所有的生命周期方法进行详细的解释。
我们按前面的想法，我们要在onDetory方法里把数据保存起来，也就是点击返回键的以后保存数据。
当我们的应用再次跑起来的时候，它又会执行onCreate方法了。这样子就会去sp里拿数据，如果有就回显出来呗！
如果是忘记了如何保存数据的，请回去看前面有课程吧，这个是网易云的视频地址，免费的哦，欢迎大家给评价哦！
https://study.163.com/course/introduction/1004334020.htm
看看后面的效果吧：
package com.sunofbeaches.activitylifecircledemo;
import android.content.SharedPreferences;
import android.os.Bundle;
import android.support.v7.app.AppCompatActivity;
import android.text.TextUtils;
import android.widget.EditText;
public class MainActivity extends AppCompatActivity {
private EditText mInputBox;
private SharedPreferences mMsgConfig;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
//前面我们学习数据存储的时候学习过了sp的存储,这里我们就使用sp来存储这些简单的数据即可
mMsgConfig = this.getSharedPreferences("MsgConfig", MODE_PRIVATE);
//输入框控件
mInputBox = (EditText) this.findViewById(R.id.message_content);
//在sp里拿到内容
String content = mMsgConfig.getString("content", null);
//如果内容不为空的话,再设置到输入框里去,显示出来。
if (content != null) {
mInputBox.setText(content);
}
}
@Override
protected void onDestroy() {
//销毁之前,拿到输入框框的内容,然后判断是否为空,不为空的话保存起来,为下一次进入的时候显示出来。
String content = mInputBox.getText().toString().trim();
if (!TextUtils.isEmpty(content)) {
mMsgConfig.edit().putString("content", content).commit();
}
super.onDestroy();
}
}
测试结果如下：
我们可以发现，当点击返回键退出应用程序的时候数据保存起来了，当我们再次打开应用程序的时候，数据回显了。
Activity生命周期的微观细聊
前面我们了解了Activity的两个生命周期方法，分别是onCreate方法和onDestroy方法。
这两个方法分别会在Activity创建和销毁的时候被调用。
其实，Activity还有别的生命周期方法，但是我们会重onCreate开始详细学习。
下面这个是整个的生命周期流程图了，来自官网：
onCreate
onCreate()这个方法是在Activity被创建的时候调用的.在这个方法里头，我们一般做一些初始化的动作，比如说，设置和获取到UI的控件，设置对应的监听事件等。
我们看看官方文档是怎么说的吧：
/**
* Called when the activity is starting. This is where most initialization
* should go: calling {@link #setContentView(int)} to inflate the
* activity's UI, using {@link #findViewById} to programmatically interact
* with widgets in the UI, calling
* {@link #managedQuery(android.net.Uri , String[], String, String[], String)} to retrieve
* cursors for data being displayed, etc.
*
* <p>You can call {@link #finish} from within this function, in
* which case onDestroy() will be immediately called without any of the rest
* of the activity lifecycle ({@link #onStart}, {@link #onResume},
* {@link #onPause}, etc) executing.
*
* <p><em>Derived classes must call through to the super class's
* implementation of this method. If they do not, an exception will be
* thrown.</em></p>
*
* @param savedInstanceState If the activity is being re-initialized after
* previously being shut down then this Bundle contains the data it most
* recently supplied in {@link #onSaveInstanceState}. <b><i>Note: Otherwise it is null.</i></b>
*
* @see #onStart
* @see #onSaveInstanceState
* @see #onRestoreInstanceState
* @see #onPostCreate
*/
能看懂原文的同学看原文，看不懂的看这里吧： onCreate这个方法会在Activity启动的时候被调用。在这个启动的阶段，也就是在这个方法的内部，你可以去做一些初始化的动作。就是前面我们说到的初始话控件，初始化事件之类的。在这个方法里，也应该通过setContentView这个方法来设置Activity加载的UI内容。使用findViewById来找到这个UI里的各控件。
managedQuery这个先不用学，就算后面学的内容提供都也是很少用到的。这个方法已经过时了，现在用的是CursorLoader这个，大家先不用管这个。我们要知道的是onCreate里面做初始化动作，并且要知道的是，Activity没有被销毁，再次启动的时候是不会被执行的，比如说，我们点击Home键的时候，Activity只是退到后台，并没有销毁掉的。所以，再次启动的时候，是不会调用onCreate方法的。
如果你在这个方法里头调用finish()方法，那么系统就会直接调用onDestroy()方法了，它会跳过onStart()方 法，会跳过onResume()方法，也会跳过onPause()方法。
一般来说，我们不会在onCreate方法里调用finish()方法的。大家理解了吗？如果没有理解的话就发帖子讨论吧。
集成自Activity的类，实现了onCreate方法，必须要调用 super.onCreate(savedInstanceState)这个方法，否则会抛出异常。
会报什么异常呢？
所以上面的原文说，你要调用 super.onCreate(savedInstanceState);
接下来我们再看看这个参数：savedInstanceState 这个参数是用来做什么的呢？这里先说一下，这个其实是用来保存数据的。
一般情况下，这个saveInstanceState为空的，那什么时候它不为空呢？当点击home键的时候，系统就会调用onSaveInstanceState这个方法，你可以在这个方法里保存临时退出时要保存的内容，比如说下载状态呀，当前的进度之类的。
先看一下例子，理解一下吧：
package com.sunofbeaches.activitylifecircledemo;
import android.support.v7.app.AppCompatActivity;
import android.os.Bundle;
import android.util.Log;
public class MainActivity extends AppCompatActivity {
private static final String TAG = "MainActivity";
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
Log.d(TAG, "onCreate...");
if (savedInstanceState != null) {
String saveData = savedInstanceState.getString("saveData");
Log.d(TAG, "上次系统杀死时保存的内容... " + saveData);
}
}
@Override
protected void onSaveInstanceState(Bundle outState) {
super.onSaveInstanceState(outState);
Log.d(TAG, "onSaveInstanceState...");
outState.putString("saveData", "我是保存的数据");
}
@Override
protected void onDestroy() {
super.onDestroy();
Log.d(TAG, "onDestroy...");
}
}
然后进行以下的操作：
启动这个应用，我们可以看到执行了onCreate方法，接着，点击home键，就发会现执行onSaveInstanceState这个方法，在这个方法里头，我们保存了一条数据。接着，我们模拟系统杀死这个应用，我们打开DDMS,直接选择当前的进程，然后stop掉，再次启动我们的应用时，就会发现，onCreate方法的时候 ，这个savedInstanceState就不为空了。并且保存着上次的数据，我们读出来。
这个onSaveInstanceState方法什么时候会执行呢？系统把你退到后台的时候会执行。 比如说：点击了home键盘；长按home键选择其他应用的时候，也就是切换应用；从当前的Activity启动到新的Activity里也会被调用；横竖屏的切换也会被调用，这里的话仅作理解，初学者暂时不需要深入学习。后面实际开发的时候，我们讲项目的时候，我们就会进行讲解了。什么场景下使用到。
好啦，我们onCreate方法先讲这么多吧。
要知道这个是生命周期方法，并且知道在这个方法里面做什么就可以了，还要注意的是onCreate要调用super的方法，否则会崩溃。这个的话不用担心，IDE在创建Activity的时候，你复写onCreate方法，直接会帮你写上的。
onStart
onStart方法的官方文档是这么写的：
/**
* Called after {@link #onCreate} — or after {@link #onRestart} when
* the activity had been stopped, but is now again being displayed to the
* user. It will be followed by {@link #onResume}.
*
* <p><em>Derived classes must call through to the super class's
* implementation of this method. If they do not, an exception will be
* thrown.</em></p>
*
* @see #onCreate
* @see #onStop
* @see #onResume
*/
这个方法会在onCreate方法以后调用，或者会在onRestart这个方法调用以后被调用，看到这里，返回去看看前面的Activity声明周期流程图吧：
同样的，也要和onCreate方法一样,需要调用super方法哦。这个方法一般比较少用到。大家后面看视频的时候留意一下就可以了。
onResume
到了onResume方法，官方原文：
/**
* Called after {@link #onRestoreInstanceState}, {@link #onRestart}, or
* {@link #onPause}, for your activity to start interacting with the user.
* This is a good place to begin animations, open exclusive-access devices
* (such as the camera), etc.
*
* <p>Keep in mind that onResume is not the best indicator that your activity
* is visible to the user; a system window such as the keyguard may be in
* front. Use {@link #onWindowFocusChanged} to know for certain that your
* activity is visible to the user (for example, to resume a game).
*
* <p><em>Derived classes must call through to the super class's
* implementation of this method. If they do not, an exception will be
* thrown.</em></p>
*
* @see #onRestoreInstanceState
* @see #onRestart
* @see #onPostResume
* @see #onPause
*/
看前面的流程图，我们可以知道，这个方法会在onRestoreInstanceState方法或者onRestart方法或者onPause这个方法以后被调用。这个方法以后就可以和用户进行交互了。在这个方法里面开始动画是不错的做法，打开相机等等操作…可是我没有做过，哈哈！！！只是翻译原文。
这个方法在实际开发中，用得最多的是什么情况呢？
就是可见的时候，需要做一些动画，比如说，我以前在做手表的时候，有这样一个效果：
直接创建不算典型的，典型的是onResume跟onCreate方法有一个区别，onCreate方法如果不销毁掉是不会再执行的，但是onResume,你退到了后台以后，再回来就会执行这个方法了。
要注意的是在onResume这个方法并不一定保证当前Activity在前台的，比如说键盘已经显示出来了。这个时候，当前Activity是失去焦点的，所以，可以使用onWindowFocusChanged这个方法来判断当前Activity是否可见。
同样的，这个方法也要调用super，否则还是会崩溃掉的。
onPause
onPause这个方法是暂停的意思是吧，暂停，什么时候会调用呢？失去焦点了
fter the next activity has been resumed and
* displayed), however in some cases there will be a direct call back to
* {@link #onResume} without going through the stopped state.
*
* <p><em>Derived classes must call through to the super class's
* implementation of this method. If they do not, an exception will be
* thrown.</em></p>
*
* @see #onResume
* @see #onSaveInstanceState
* @see #onStop
*/
这个方法也是声明周期方法，它会在当前Activity进入后台但又没被杀死的时候会被调用。它对应着onResume，其实我们的声明周期一般来说是对应着的。 比如说：
onStart—-onStop onResume—onPause onCreate—-onDestroy
理解了吗？
在这个方法里不要做耗时操作，假设说，你要打开另外一个Activity,真到这个方法的onPause方法返回了，才会去启动另外一个Activity。
在这个方法里头，一般保存正在编辑的数据，除了保存数据以外，还可以停止动画，因为它是跟onResume对应的嘛。在onResume开始动画，我们要是还有一些在循环播放的动画，我们可以在这个方法里头暂停掉它。在这个方法里头释放资源也是可以的，释放掉资源可以更快地启动到下一个界面。
某些情况下系统可能会回收资源。所以有些东西你需要在这个地方进行保存。通常来说，如果是系统干的坏事，它会调用onSaveInstanceState这个方法的，在这个方法里头保存就好，前面我们已经讲过了。
这个方法被调用以后，当被启动的Activity可见的时候，接下来就会调用onStop方法了。但是有些情况下直接调用新的Activity的onResume方法，不会调用当前Activity的onStop方法.
这个方法也要调用super的方法，否则也会崩溃掉。
onStop
停止的回调，这个方法一般是执行完onPause,要退出了，则会调用。假设说，顶部有一个透明的Activity，则不会调用当前的onStop方法，但会调用到onPause方法。
/**
* Called when you are no longer visible to the user. You will next
* receive either {@link #onRestart}, {@link #onDestroy}, or nothing,
* depending on later user activity.
*
* <p>Note that this method may never be called, in low memory situations
* where the system does not have enough memory to keep your activity's
* process running after its {@link #onPause} method is called.
*
* <p><em>Derived classes must call through to the super class's
* implementation of this method. If they do not, an exception will be
* thrown.</em></p>
*
* @see #onRestart
* @see #onResume
* @see #onSaveInstanceState
* @see #onDestroy
*/
onStop方法会在你再也看不到当前Activity的时候调用，当上面的Activity是透明你的时候，那么是不会调用的，这个是考点哦。
这个方法以有两个可能，要么被onRestart，要么就被调用onDestroy，或者啥也不干，这取决于后面的操作。有些情况下这个方法可能不会被执行。比如说系统的内存不足以来跑当前的Activity的时候，调用了onPause就不调用onStop方法了,所以在这个方法里头不要做一些保存数据的东西,可能不安全,没有保障.
onDestroy
onDestroy这个方法，我们早在前面就已经用了是吧，我们保存内容，并且在onCreate的方法我们回显数据。
/**
* Perform any final cleanup before an activity is destroyed. This can
* happen either because the activity is finishing (someone called
* {@link #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 {@link #isFinishing} method.
*
* <p><em>Note: do not count on this method being called as a place for
* saving data! For example, if an activity is editing data in a content
* provider, those edits should be committed in either {@link #onPause} or
* {@link #onSaveInstanceState}, not here.</em> This method is usually implemented to
* free resources like threads that are associated with an activity, so
* that a destroyed activity does not leave such things around while the
* rest of its application is still running. There are situations where
* the system will simply kill the activity's hosting process without
* calling this method (or any others) in it, so it should not be used to
* do things that are intended to remain around after the process goes
* away.
*
* <p><em>Derived classes must call through to the super class's
* implementation of this method. If they do not, an exception will be
* thrown.</em></p>
*
* @see #onPause
* @see #onStop
* @see #finish
* @see #isFinishing
*/
在这个方法里做释放资源的动作，比如说，取消一些广播的注册，解绑服务。不要在这个方法里保存数据哦，前面那个例子是为了给大家演示。在onPause方法保存数据或者在onSaveInstanceState方法里保存数据。就是不要在这里保存数据就好。这个方法通常用于释放资源，比如说释放线程，释放掉的话就不会泄露了。有些情况下不会调用这个方法，所以这里不要使用一直在跑的进程。
这个方法也要调用super的方法，否则的话会崩溃掉的。
onPause和onStop
我们前面详细地翻译和解释了每个生命周期的特点，不管是同学们在看视频，还是看文章自己做实验。我们会发现当我们点击Home键的时候，生命周期会执行–>onPause—>onStop。
前面我们也提到了，onPause是失去焦点的意思，对应着onResume获得焦点。
onStop是不可见了，所以。我们的Activity先是失去焦点，再是不可见！于是就有了这样的生命周期：onPause–>onStop
但是，面试的时候可能会有一种特殊的情况：我们的当前Activity，去启动另外一个透明的Activity时，当前的Activity生命周期变化是怎么样的？
答案是：onPause，没有onStop。因为是透明的，所以前一个Activity还是可见的。只是失去焦点而已，并不是不可见！
验证代码如下：
先是第一个Activity：
package com.sunofbeaches.activitylifecircledemo;
import android.app.Activity;
import android.content.Intent;
import android.os.Bundle;
import android.util.Log;
import android.view.View;
/**
* Created by TrillGates on 17/12/12.
* God bless my code!
*/
public class FirstActivity extends Activity {
private static final String TAG = "FirstActivity";
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_first);
Log.d(TAG, "onCreate....");
}
public void skip2SecondActivity(View view) {
Intent intent = new Intent(this, SecondActivity.class);
startActivity(intent);
}
@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....");
}
}
第一个Activity的布局很简单：
第二个Activity的代码，其实什么都没有写：
package com.sunofbeaches.activitylifecircledemo;
import android.app.Activity;
import android.os.Bundle;
/**
* Created by TrillGates on 17/12/12.
* God bless my code!
*/
public class SecondActivity extends Activity {
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_second);
}
}
界面：
我们设置一下第二个样式为透明：
<?xml version="1.0" encoding="utf-8"?>
<manifest xmlns:android="https://schemas.android.com/apk/res/android"
package="com.sunofbeaches.activitylifecircledemo">
<application
android:allowBackup="true"
android:icon="@mipmap/ic_launcher"
android:label="@string/app_name"
android:supportsRtl="true"
android:theme="@style/AppTheme">
<activity android:name=".MainActivity">
</activity>
<activity android:name=".FirstActivity">
<intent-filter>
<action android:name="android.intent.action.MAIN"/>
<category android:name="android.intent.category.LAUNCHER"/>
</intent-filter>
</activity>
<activity
android:name=".SecondActivity"
android:theme="@android:style/Theme.Translucent"></activity>
</application>
</manifest>
当我们把应用跑起来，点击跳转到第二个界面，我们看生命周期的变化。
当我们把应用跑起来，点击跳转到第二个界面，我们看生命周期的变化。
Activity生命周期的分类
完整的声明周期：
也就是说，从onCreate开始，一直到onDestroy方法执行完成。这就是一个完整的声明周期。 一般来说，完整的声明周期走完所有的声明周期方法。在onCreate方法的时候初始化资源，在onDestroy方法释放资源。
Activity可见的声明周期：
可见的声明周期就是调用onStart到调用onStop这段声明周期。在这其间，用户可以看到UI,也可以进行交互。在这两个方法之间，你可以让要显示的数据显示给用户。栗子我就不说了。
前台生命周期：
什么是前台呢？也就是正在操作的，相对于后台运行来说的。前台生命周期是从onResume到onPause这期间。在这期间的话,Activity会跑在前台。Activity可能会频繁地切换于onResume和onPause这两个方法间。前面我们讲到了，onResume是获取到了焦点了，onPause就失去焦点了。
原文的内容如下：
Activity的生命周期宏观概括
声明周期就像人的各个阶段，但是有些阶段不是每个人都经历的，而重点是在对应的阶段做对应的事情。这就是总结啦！
实际的使用，还得从实际开发中去体会，这节课了解一下先，在以后的工作中就慢慢地理解了。但是呢，这样子还不够的，因为出来工作的时候，面试可能会遇到哦。