[移动开发] Android初体验—

开发: C++知识库 Java知识库 JavaScript Python PHP知识库人工智能区块链大数据移动开发嵌入式开发工具数据结构与算法开发测试游戏开发网络协议系统运维
教程: HTML教程 CSS教程 JavaScript教程 Go语言教程 JQuery教程 VUE教程 VUE3教程 Bootstrap教程 SQL数据库教程 C语言教程 C++教程 Java教程 Python教程 Python3教程 C#教程
数码: 电脑笔记本显卡显示器固态硬盘硬盘耳机手机 iphone vivo oppo 小米华为单反装机图拉丁

-> 移动开发 -> Android初体验——探究活动（2） -> 正文阅读

[移动开发]Android初体验——探究活动（2）

文章目录

活动的生命周期

掌握活动的生命周期对任何Android开发者来说都非常重要，当你深人理解活动的生命周期之后，就可以写出更加连贯流畅的程序，并在如何合理管理应用资源方面发挥得游刃有余。你的应用程序将会拥有更好的用户体验。

返回栈

Android 中的活动是可以层叠的。我们每启动一个新的活动，就会覆盖在原活动之上，然后点击Back键会销毁最上面的活动，下面的一个活动就会重新显示出来。

其实Android是使用任务栈( Task)来管理活动的，一个任务就是一组存放在栈里的活动的集合，这个栈也被称作返回栈( Back Stack )。栈是一种后进先出的数据结构，在默认情况下，每当我们启动了一个新的活动，它会在返回栈中入栈，并处于栈顶的位置。而每当我们按下Back键或调用finish()方法去销毁一个活动时，处于栈顶的活动会出栈，这时前一个栈的活动就会重新处于栈顶的位置。系统总是会显示处于栈顶的活动给用户。
在这里插入图片描述

活动状态

每个活动在其生命周期中最多有四种状态

运行状态
当一个活动位于返回栈的栈顶时，这时活动就处于运行状态。系统最不愿意回收的就是处于运行状态的活动，因为这会带来非常差的用户体验。
暂停状态
当一个活动不再处于栈顶位置，但仍然可见时,这时活动就进人了暂停状态。比如对话框形式的活动只会占用屏幕中间的部分区域,你很快就会在后面看到这种活动。处于暂停状态的活动仍然是完全存活着的，系统也不愿意去回收这种活动(因为它还是可见的，回收可见的东西都会在用户体验方面有不好的影响)，只有在内存极低的情况下，系统才会去考虑回收这种活动。
停止状态
当一个活动不再处于栈顶位置,并且完全不可见的时候，就进入了停止状态。系统仍然会为这种活动保存相应的状态和成员变量，但是这并不是完全可靠的，当其他地方需要内存时，处于停止状态的活动有可能会被系统回收。
销毁状态
当一个活动从返回栈中移除后就变成了销毁状态。系统会最倾向于回收处于这种状态的活动，从而保证手机的内存充足。

活动的生存期

Activity类中定义了7个回调方法，覆盖了活动生命周期的每一个环节，下面就来一一介绍这7个方法。

onCreate()。这个方法你已经看到过很多次了，每个活动中我们都重写了这个方法，它会在活动第一次被创建的时候调用。你应该在这个方法中完成活动的初始化操作，比如说加载布局、绑定事件等。
onStart()。这个方法在活动由不可见变为可见的时候调用。
onResume()。这个方法在活动准备好和用户进行交互的时候调用。此时的活动一定位于返回栈的栈顶，并且处于运行状态。
onPause()。这个方法在系统准备去启动或者恢复另一个活动的时候调用。我们通常会在这个方法中将一些消耗CPU的资源释放掉，以及保存一些关键数据，但这个方法的执行速度一定要快，不然会影响到新的栈顶活动的使用。
onStop()。这个方法在活动完全不可见的时候调用。它和onPause( )`方法的主要区别在于，如果启动的新活动是一个对话框式的活动，那么onPause() 方法会得到执行，而onStop()方法并不会执行。
onDestroy()。这个方法在活动被销毁之前调用,之后活动的状态将变为销毁状态。
onRestart()。这个方法在活动由停止状态变为运行状态之前调用，也就是活动被重新启动了。

以上7个方法中除了onRestart()方法，其他都是两两相对的，从而又可以将活动分为3种生存期。

完整生存期。活动在onCreate()方法和onDestroy()方法之间所经历的,就是完整生存期。一般情况下，一个活动会在onCreate()方法中完成各种初始化操作，而在onDestroy()方法中完成释放内存的操作。
可见生存期。活动在onStart()方法和onStop()方法之间所经历的，就是可见生存期。在可见生存期内，活动对于用户总是可见的，即便有可能无法和用户进行交互。我们可以通过这两个方法，合理地管理那些对用户可见的资源。比如在onStart()方法中对资源进行加载，而在onStop()方法中对资源进行释放，从而保证处于停止状态的活动不会占用过多内存。
前台生存期。活动在onResume( )方法和onPause()方法之间所经历的就是前台生存期。在前台生存期内，活动总是处于运行状态的，此时的活动是可以和用户进行交互的，我们平时看到和接触最多的也就是这个状态下的活动。

体验活动的生命周期

创建两个子活动——NormalActivity和DialogActivity，布局normal_layout和dialog_layout
normal_layout.xml

<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:orientation="vertical"
    android:layout_width="match_parent"
    android:layout_height="match_parent">

    <TextView
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:text="This is a normal activity"/>


</LinearLayout>

dialog_layout.xml

<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:orientation="vertical"
    android:layout_width="match_parent"
    android:layout_height="match_parent">

    <TextView
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:text="This is a dialog activity"/>


</LinearLayout>

AndroidManifest.xml

        <activity android:name=".DialogActivity"
            android:theme="@style/Theme.AppCompat.Dialog">
        </activity>
        <activity android:name=".NormalActivity" >
        </activity>

两个活动的注册代码，在DialogActivity中添加了android:theme属性为当前活动指定主题。@style/Theme.AppCompat.Dialog指对话框式的主题

activity_main.xml

<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:orientation="vertical"
    android:layout_width="match_parent"
    android:layout_height="match_parent">

    <Button
        android:id="@+id/start_normal_activity"
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:text="Start NormalActivity"/>

    <Button
        android:id="@+id/start_dialog_activity"
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:text="Start DialogActivity"/>


</LinearLayout>

增加了两个按钮，一个用于启动LinearLayout，一个启动DialogActivity
MainActivity

public class MainActivity extends AppCompatActivity {
    public static final String TAG = "MainActivity";

    @Override
    protected void onSaveInstanceState(Bundle outState) {
        super.onSaveInstanceState(outState);
        String tempData = "Something you just typed";
        outState.putString("data_key", tempData);
    }

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        Log.d(TAG,"onCreate");
        Button startNormalActivity = (Button) findViewById(R.id.start_normal_activity);
        Button startDialogActivity = (Button) findViewById(R.id.start_dialog_activity);
        startNormalActivity.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View view) {
                Intent intent = new Intent(MainActivity.this, NormalActivity.class);
                startActivity(intent);
            }
        });

        startDialogActivity.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View view) {
                Intent intent = new Intent(MainActivity.this, DialogActivity.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");
    }

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

可以更直观的观察活动的生命周期
在这里插入图片描述

可以看到，当MainActivity 第一次被创建时会依次执行onCreate() 、onStart()和onResume()方法。然后点击第一个按钮，启动NormalActivity,

由于NormalActivity已经把MainActivity完全遮挡住，因此onPause()和onStop()方法都会得到执行。然后按下Back键返回MainActivity.
在这里插入图片描述
由于之前MainActivity已经进入了停止状态，所以onRestart()方法会得到执行，之后又会依次执行onStart()和onResume()方法。注意此时onCreate( )方法不会执行,因为MainActivity并没有重新创建。
点击第二个按钮，启动DialogActivity
在这里插入图片描述

可以看到，只有onPause() 方法得到了执行，onStop() 方法并没有执行，这是因为DialogActivity并没有完全遮挡住MainActivity，此时MainActivity只是进入了暂停状态，并没有进入停止状态。相应地, 按下Back键返回MainActivity也应该只有onResume()方法会得到执行。
在这里插入图片描述
退出程序后

依次会执行onPause()、onStop( )和onDestroy()方法，最终销MainActivity。

活动被回收了怎么办

当一个活动进入停止状态是有可能被系统回收的，此时如果返回这个活动，并不会执行onRestart()方法，而是会执行onCreate（）方法，因为活动在这种情况下会被重新创建一次。
但如果该活动中存在临时数据和状态，那么此时会发生数据丢失。Activity中提供了一个onSaveInstanceState（）回调方法，这个方法可以保证在活动被回收前一定会被调用，因此我们可以通过这个方法来解决活动被回收时临时数据得不到保持的问题。
onSaveInstanceState()方法会携带一个 Bundle类型的参数，Bundle 提供了一系列的方法用于保存数据，比如可以使用putString()方法保存字符串，使用putInt()方法保存整型数据，以此类推。每个保存方法需要传人两个参数，第一个参数是键,用于后面从Bundle中取值，第二个参数式真正要保存的内容。
MainActivity中添加如下代码就可以将临时数据保存。

    @Override
    protected void onSaveInstanceState(Bundle outState) {
        super.onSaveInstanceState(outState);
        String tempData = "Something you just typed";
        outState.putString("data_key", tempData);
    }

onCreate()方法其实也有一个Bundle类型的参数。这个参数在一般情况下都是null,但是如果在活动被系统回收之前有通过onSaveInstanceState( )方法来保存数据的话，这个参数就会带有之前所保存的全部数据，我们只需要再通过相应的取值方法将数据取出即可。
修改onCreate（）方法

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        Log.d(TAG,"onCreate");
        if (savedInstanceState != null) {
            String tempData = savedInstanceState.getString("data_key");
            Log.d(TAG, tempData);
        }
        Button startNormalActivity = (Button) findViewById(R.id.start_normal_activity);
        Button startDialogActivity = (Button) findViewById(R.id.start_dialog_activity);
        startNormalActivity.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View view) {
                Intent intent = new Intent(MainActivity.this, NormalActivity.class);
                startActivity(intent);
            }
        });

        startDialogActivity.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View view) {
                Intent intent = new Intent(MainActivity.this, DialogActivity.class);
                startActivity(intent);
            }
        });


    }

增加if语句判断Bundle，取出值后进行相应的恢复操作即可，这里我们只是简单的打印了一下。
该方法与Intent方法有些类似，Intent还可以结合Bundle一起用于传递数据，首先可以将需要传递的数据保存在Bundle对象中，然后将Bundle对象存在Intent中，到了目标活动后先从Intent中取出Bundle，再从Bundle中取出数据。

活动的启动模式

在实际项目中我们应该根据特定的需求为每个活动指定恰当的启动模式。启动模式一共有4种，分别是standard、 singleTop、 singleTask 和singleInstance ,可以在AndroidManifest.xml中通过给<activity>标签指定android: launchMode属性来选择启动模式。

standard

standard是活动默认的启动模式，在不进行显式指定的情况下，所有活动都会自动使用这种启动模式。因此,到目前为止我们写过的所有活动都是使用的standard模式。Android是使用返回栈来管理活动的，在standard 模式(即默认情况)下，每当启动一个新的活动，它就会在返回栈中人栈，并处于栈顶的位置。对于使standard模式的活动,系统不会在乎这个活动是否已经在返回栈中存在，每次启动都会创建该活动的一个新的实例。
我们现在通过实践来体会一下standard 模式。
首先，修改FirstActivity中的onCreate（）方法。

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        Log.d("FirstActivity", this.toString());
	    setContentView(R.layout.first_layout);
        Button button1 = (Button) findViewById(R.id.button_1);
        button1.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View view) {
                //在FirstActivity活动的基础上启动FristActivity
                Intent intent = new Intent(FirstActivity.this, FirstActivity.class);
                startActivity(intent);

            }
        });
    }

运行程序，在FirstActivity界面连续点击两次按钮，可以从打印信息中发现没点一次按钮就会创建出一个新的FirstActivity实例，此时返回栈中也会存在三个FirstActivity实例，需要连续按3次Back才能退出程序。
在这里插入图片描述

singleTop

当活动的启动模式指定为singleTop,在启动活动时如果发现返回栈的栈项已经是该活动，则认为可以直接使用它，不会再创建新的活动实例。
修改AndroidManifest.xml中FirstActivity的启动模式。

        <activity
            android:name=".FirstActivity"
            android:launchMode="singleTop"
            android:label="This is FirstActivity">
            <intent-filter>
                <action android:name="android.intent.action.MAIN" />
                <category android:name="android.intent.category.LAUNCHER" />
            </intent-filter>
        </activity>

重新运行程序，查看lofcat会看到已经创建了一个FirstActivity的实例。但是之后不管你点击多少次按钮都不会再有新的打印信息出现，因为目前FirstActivity 已经处于返回栈的栈顶，每当想要再启动一个FirstActivity时都会直接使用栈顶的活动，因此FirstActivity也只会有一个实例，仅按-一次Back键就可以退出程序。
不过当FirstActivity不在栈顶时，这时启动FirstActivity，还是会创建新的实例。
如果为FirstActivity中的按钮添加点击事件，点击后会进入SecondActivity中，为SecondActivity中也添加点击事件，点击进入FirstActivity中，此时会创建一个新的FirstActivity实例，因为栈顶活动已经变成SecondActivity。
在这里插入图片描述

singleTask

当活动的启动模式指定为singleTask, 每次启动该活动时系统首先会在返回栈中检查是否存在该活动的实例，如果发现已经存在则直接使用该实例，并把在这个活动之上的所有活动统统出栈，如果没有发现就会创建一个新的活动实例。
修改FirstActivity的启动模式

        <activity
            android:name=".FirstActivity"
            android:launchMode="singleTask"
            android:label="This is FirstActivity">
            <intent-filter>
                <action android:name="android.intent.action.MAIN" />
                <category android:name="android.intent.category.LAUNCHER" />
            </intent-filter>
        </activity>

此时，在SecondActivity中启动FirstActivity 时，会发现返回栈中已经存在一个FirstActivity的实例，并且是在SecondActivity的下面，于是SecondActivity会从返回栈中出栈，而FirstActivity重新成为了栈顶活动。
在这里插入图片描述

singleInstance

不同于以上3种启动模式,指定为singleInstance模式的活动会启用一个新的返回栈来管理这个活动(其实如果singleTask模式指定了不同的taskAffinity,也会启动一个新的返回栈)。可以实现其他程序和我们的程序可以共享这个活动的实例,在这种模式下会有一个单独的返回栈来管理这个活动,不管是哪个应用程序来访问这个活动，都共用的同一个返回栈，也就解决了共享活动实例的问题。
实践一下 修改SecondActivity的启动模式，指定为singleInstance

        <activity
            android:name=".SecondActivity"
            android:launchMode="singleInstance">
            
            <intent-filter>
                <action android:name="com.example.activitytest.ACTION_START" />
                <category android:name="android.intent.category.DEFAULT" />
                <category android:name="com.example.activitytest.MY_CATEGORY" />
            </intent-filter>
        </activity>

修改FirstActivity中onCreate（）方法

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        Log.d("FirstActivity", "Task id is " + getTaskId());
        setContentView(R.layout.first_layout);
        Button button1 = (Button) findViewById(R.id.button_1);
        button1.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View view) {
                //在FirstActivity活动的基础上启动SecondActivity
                Intent intent = new Intent(FirstActivity.this, SecondActivity.class);
                startActivity(intent);
            }
        });
    }

在onCreate（）方法中打印了当前返回栈的id，然后修改SecondActivity中的onCreate（）方法

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        Log.d("SecondActivity","Task id is " + getTaskId());
   	setContentView(R.layout.second_layout);
        Button button2 = (Button) findViewById(R.id.button_2);
        button2.setOnClickListener(new View.OnClickListener() {

            @Override
            public void onClick(View view) {
                Intent intent = new Intent(SecondActivity.this, ThirdActivity.class);
                startActivity(intent);
            }
        });
    }

在onCreate（）方法中打印了当前返回栈的id，修改了点击事件的代码，用于启动ThirdActivity，最后修改ThirdActivity中onCreate（）方法的代码

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        Log.d("ThirdActivity", "Task id is " + getTaskId());
        setContentView(R.layout.third_layout);
        });
    }

仍然是在onCreate( )方法中打印了当前返回栈的id。现在重新运行程序，在FirstActivity界面点击按钮进人到SecondActivity,然后在SecondActivity界面点击按钮进人到ThirdActivity。
在这里插入图片描述

通过查看打印信息可以看到，SecondActivity 的Task id不同于FirstActivity 和ThirdActivity，这说明SecondActivity确实是存放在一个单独的返回栈里的，而且这个栈中只有SecondActivity 这一个活动。
然后我们按下Back 键进行返回，你会发现ThirdActivity竟然直接返回到了FirstActivity,再按下Back键又会返回到SecondActivity,再按下Back键才会退出程序。
由于FirstActivity和ThirdActivity是存放在同一个返回栈里的，当在ThirdActivity的界面按下Back键, ThirdActivity 会从返回栈中出栈，那么FirstActivity 就成为了栈顶活动显示在界面上，因此也就出现了从ThirdActivity 直接返回到FirstActivity 的情况。然后在FirstActivity界面再次按下Back 键，这时当前的返回栈已经空了，于是就显示了另一个返回栈的栈顶活动，即SecondActivity。最后再次按下Back键，这时所有返回栈都已经空了，也就自然退出了程序。
在这里插入图片描述

活动的最佳实践

知晓当前是在哪一个活动

新建一个BaseActivity类，让BaseActivity继承AppCompatActivity，并重写onCreate()方法，获得当前实例的类名并打印

public class BaseActivity extends AppCompatActivity {
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        Log.d("BaseActivity", getClass().getSimpleName());
    }
}

接下来，让ActivityTest中的所有类都继承它
在这里插入图片描述
现在当我们进入哪个活动的界面哪个活动的类名就会被打印出来，这样我们就可以知道我们当前界面对应哪个活动了

随时随地退出程序

只需要用一个专门的集合类对所有活动进行管理即可。
新建一个ActivityCollector类作为活动管理器

public class ActivityCollector {
    public static List<Activity> activities = new ArrayList<>();
    //创建List集合管理
    
    //添加活动
    public static void addActivity(Activity activity) {
        activities.add(activity);
    }
    
    //移除活动
    public static void removeActivity(Activity activity) {
        activities.remove(activity);
    }
    
    //销毁活动
    public static void finishAll() {
        for(Activity activity : activities) {
            if(!activity.isFinishing()) {
                activity.finish();
            }
        }
    }
}

在BaseActivity的onCreate()方法中调用了ActivityCollector 的addActivity()方法,表明将当前正在创建的活动添加到活动管理器里。然后在BaseActivity中重写onDestroy()方法，并调用了ActivityCollector 的removeActivity()方法，表明将一个马上要销毁的活动从活动管理器里移除。

从此以后，不管你想在什么地方退出程序，只需要调用ActivityCollector. finishAll()方法就可以了。

当然你还可以在销毁所有活动的代码后面再加上杀掉当前进程的代码，以保证程序完全退出，杀掉进程的代码如下所示:

android.os.Process.killProcess(android.os.Process.myPid());

其中，killProcess()方法用于杀掉-一个进程，它接收一个进程id参数，我们可以通过myPid()方法来获得当前程序的进程id。需要注意的是killProcess()方法只能用于杀掉当前程序的进程，我们不能使用这个方法去杀掉其他程序。

启动活动的最佳写法

假设SecondActivity 中需要用到两个非常重要的字符串参数，在启动SecondActivity的时候必须要传递过来，我们可以这么写

    public static void actionAtart(Context context, String data1, String data2) {
        Intent intent = new Intent(context, SecondActivity.class);
        intent.putExtra("param1", data1);
        intent.putExtra("param2", data2);
        context.startActivity(intent);
    }

添加了一个actionStart()方法，在这个方法中完成了Intent 的构建,另外所有需要的数据都是通过actionStart ()方法的参数传递过来的，然后把它们存储到Intent中，最后调用startActivity()方法启动SecondActivity。
这样就可以将所需的参数一目了然的体现出来，在启动活动时也只需要一行代码

                //返回数据给下一个活动
                //Intent intent = new Intent(FirstActivity.this, SecondActivity.class);
                //startActivityForResult(intent , 1);
                SecondActivity.actionAtart(FirstActivity.this, "data1", "data2");