Explication détaillée du cycle de vie de l'activité et du mode de chargement dans le développement Android

Cet article vous présentera le cycle de vie d'Activity Si vous avez étudié iOS, le cycle de vie d'Activity est très similaire au cycle de vie de ViewController dans iOS. Le cycle de vie n'est pas difficile à comprendre. Le cycle de vie d'une personne n'est rien d'autre que la naissance, la vieillesse, la maladie et la mort, et le cycle de vie d'une fleur correspond au moment où elle fleurit et se fane. Le cycle de vie de l'activité dans Android n'est rien de plus que le processus depuis la création de l'activité jusqu'à sa mort. Ce blog présentera les différentes étapes du cycle de vie de l'activité et jettera un aperçu du cycle de vie de l'activité à travers des exemples. Il est crucial de comprendre le cycle de vie de l'activité, car ce n'est qu'en comprenant chaque étape de chaque cycle de vie que l'on peut faire différentes choses à différentes étapes.

Ensuite, nous présenterons le cycle de vie de l'activité à travers un exemple. Dans cette démo, il y aura une MainActivity qui est la première activité affichée après le démarrage de l'application. Il y a un bouton sur MainActivity. En cliquant sur ce bouton, vous passerez à SecondActivity. En cliquant sur la touche de retour, vous reviendrez de SecondActivity à MainActivity. Grâce à ces séries de changements d'activité, nous observerons le cycle de vie de l'activité en imprimant le journal.

1. Écriture du code

En fait, le code de ce blog est très simple. Il s'agit de réécrire les méthodes à différentes étapes du cycle de vie de l'activité, puis d'imprimer le journal dans la méthode. pour marquer l'étape de ce cycle de vie. L'interface utilisateur de la démo est également très simple, je n'entrerai donc pas trop dans les détails sur le fichier de mise en page de l'activité. Ensuite, jetez un œil aux codes clés des deux activités.

1. Le code ci-dessous est le code clé de MainActivity. Il réécrit différentes étapes du cycle de vie de l'activité, puis imprime le journal pour marquer quelle méthode dans quelle activité. Obtenez le bouton par identifiant dans la méthode onCreate(), puis liez l'événement click au bouton et passez à SecondActivity lorsque vous cliquez sur le bouton. Le code spécifique est le suivant.

@Override
  protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.activity_main);
    Log.d("lifeCycle", "MainActivity: 我是onCreate方法，我会在Activity第一次被创建是调用");
    Button jumpButton = (Button) findViewById(R.id.jump_second_button);
    jumpButton.setOnClickListener(new View.OnClickListener() {
      @Override
      public void onClick(View v) {
        //跳转到SecondActivity
        Intent intent = new Intent(MainActivity.this, SecondActivity.class);
        startActivity(intent);
      }
    });
  }
  //Ctrl + O 选择父类中的方法进行重写
  @Override
  protected void onStart() {
    super.onStart();
    Log.d("lifeCycle", "MainActivity: 我是onStart方法，我会在Activity由不可见变为可见时调用");
  }
  @Override
  protected void onResume() {
    super.onResume();
    Log.d("lifeCycle", "MainActivity: 我是onResume方法，我在Activity处于运行状态时调用");
  }
  @Override
  protected void onPause() {
    super.onPause();
    Log.d("lifeCycle", "MainActivity: 我是onPause方法，我会在Activity暂停时调用");
  }
  @Override
  protected void onStop() {
    super.onStop();
    Log.d("lifeCycle", "MainActivity: 我是onStop方法，我会在Activity停止时调用");
  }
  @Override
  protected void onRestart() {
    super.onRestart();
    Log.d("lifeCycle", "MainActivity: 我是onRestart方法，我会在Activty从停止状态变为运行状态时调用");
  }
  @Override
  protected void onDestroy() {
    super.onDestroy();
    Log.d("lifeCycle", "MainActivity: 我是onDestroy方法，我会在Activty销毁之前调用");
  }

2. La méthode ci-dessus est également réécrite dans SecondActivity. La seule différence est de changer MainActivity dans le journal ci-dessus en SecondActivity.

2. Exécutez et observez le journal imprimé

Exécutez notre application, puis observez le journal imprimé et analysez le cycle de vie de l'activité à travers des exemples. Les étapes spécifiques sont les suivantes :

1. Créer et activer une activité

Le journal imprimé lors de la première ouverture de l'application est comme indiqué ci-dessous. MainActivity est la première chose que vous voyez lorsque vous ouvrez l'application. Grâce au journal, nous pouvons facilement voir que les trois méthodes suivantes doivent être appelées lorsque MainActivity apparaît pour la première fois. Après les trois méthodes ci-dessous, MainActivty sera créée, puis deviendra visible. , et enfin dans un état de fonctionnement.

Méthode (1).onCreate() : Cette méthode sera appelée lors de la première création de l'activité. Dans la démo précédente, nous avons chargé la disposition et/ou les contrôles de l'activité et les événements associés dans celle-ci. méthode.

Méthode (2).onStar()t : Ensuite, la méthode onStart() sera exécutée. Cette méthode sera appelée lorsque l'activité passe d'invisible à visible.

(3).Méthode onResume : Une fois que l'activité devient visible, la méthode onResume doit être appelée pour la faire passer à l'état d'exécution.

2. Basculer entre les activités

Pour que ce soit plus clair, avant de cliquer sur le bouton pour passer à SecondActivity, nous pouvons effacer le journal. en bas à gauche La marque du seau est utilisée pour effacer les journaux précédemment imprimés. Le journal imprimé ci-dessous est le journal imprimé lorsque le bouton de saut est cliqué. Au cours de ce processus de commutation, MianActivty cessera de fonctionner et deviendra invisible, et SecondActivy sera créé et en cours d'exécution. Les étapes spécifiques sont les suivantes.

Méthode (1).onPause() : Lorsque vous cliquez sur le bouton de saut, la MainActivity en cours d'exécution appellera onPause() pour s'arrêter, mais elle est toujours visible.

(2). Ensuite, SecondActivity appelle la méthode onCreate() pour créer, la méthode onStart() pour afficher et la méthode onResume() pour exécuter.

Méthode (3).onStop() : Lorsque SecondActivity est en cours d'exécution, MainActivity est complètement invisible, donc la méthode onStop() sera appelée pour entrer dans un état d'arrêt complètement invisible.

3. Retour d'une autre activité

Cliquez sur la touche de retour de SecondActivity pour revenir à MainActivity depuis SecondActivity. Le journal ci-dessous est le journal imprimé lorsque le bouton de retour est cliqué.

(1) Méthode onPause() : Après avoir cliqué sur le bouton de retour, SecondActivity appellera la méthode onPause() et entrera dans l'état d'exécution en pause.

(2)Méthode onRestart() : Ensuite, MainActivity appellera la méthode onRestart() pour passer de l'état arrêté à l'état d'exécution. Ensuite, MainActivity appellera la méthode onStart d'invisible à visible, puis appellera la méthode onResume() pour enfin entrer dans l'état d'exécution.

(3)当返回到MainActivity中并且MainActivity处于运行状态后，SecondActivity会调用onStop方法，停止运行并不可见。因为SecondActivty做的事出栈操作，停止运行后，就会调用onDestory方法进行销毁。下此在进入SecondActivity中时，还是从onCreate方法进行执行。

4.Activity退出并销毁

接着在MainActivity中点击返回按钮就会退出App了，下方是退出App时打印的Log信息。MainActivty先调用onPause()方法变为暂停运行状态，然后再调用onStop()方法停止运行，最后调用onDestroy()方法进行销毁。

三.生命周期流程图

1.上面是用语言通过实例打印出的Log来描述两个Activity切换的生命周期，接下来将用一个流程图来描述这一过程，具体流程图如下。

2.通过上面的实例不难分析出一个Activity的生命周期分为哪些阶段，并且很容易的看出哪些阶段在什么时候执行，所以我们很容易的画出一个Activity的生命周期，下方的流程图是一个Activity的生命周期。

四.Activity的加载模式

Activity的启用模式也较为简单，它会在活动切换时用到。Activity的启动模式分为四种，standard、singleTop、singleTask、singleInstance模式。接下来将为大家详细的介绍一下这几种加载模式。

Activity的加载模式可以在配置文件AndroidManifest.xml中进行配置，配置项为android:launchMode具体如下图所示：

1.standard模式

在Activity的栈中无论该活动有没有加入栈，活动就会被创建。测试方式是把MainActivity的launchMode设置成standard, 在MainActivity中添加一个按钮，点击按钮使用Intent跳转到当前Activity，看onCreate方法中打印的Log。点击按钮的方法如下：

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

standard加载模式的栈如下所示，无论栈中有没有该对象的实例，都会被创建。

2.singleTop模式

只要被创建的活动不位于栈的顶部，该活动就会被创建入栈。如果将要被创建的活动位于栈的顶部，该活动的实例就不会被创建。测试方法，把上面的模式直接改成singleTop模式，MainActivty往自己身上跳转就不会从新创建一个新的实例，会重用之前在栈顶中的实例。如果是MainActivty跳转到SecondActivty, 然后SecondActivity再次跳转到MainActivty, 那么此时的MainActivity将会被创建，因为栈顶是SecondActivity。如下所示：

3.singleTask模式

单任务模式，这个也不难理解，如果从MainActivty跳转到SecondActivity, 如果再从SecondActivty跳转到MainActivity, 在单任务模式下MainActivity已经在栈中，就会把它之前的Activity出栈，使其处于在栈顶活跃的位置。原理如下图所示：

4.singleInstance

可以看成单例模式，这个比较特殊，被设置成singleInstance的Activity将会放入另一个栈中，因为这样为了便于共用。上面3中模式位于同一个栈中。下方ThirdActivity跳转到一个加载模式为singleInstance的Activity中。

C'est tout pour le cycle de vie de l'activité d'aujourd'hui. Le contenu correspondant sera mis à jour dans le prochain blog.

Pour des explications plus détaillées sur le cycle de vie et le mode de chargement de l'activité dans le développement Android, veuillez faire attention au site Web PHP chinois !