Quelle est la bonne façon d'implémenter l'interface OnClickListener pour de nombreux boutons

Mon activité Android contient plusieurs boutons qui ont tous besoin d'un OnClickListener. J'ai vu beaucoup de façons différentes de le faire, telles que:

• Implémentation de l'interface dans la classe d'activité
• Création d'une classe distincte qui implémente l'interface
• Définition d'une classe interne anonyme pour chaque bouton.

J'ai vu de nombreux exemples de chaque approche. Cependant, il n'est pas clair pour moi pourquoi une approche serait utilisée au lieu d'une autre. Les différences entre ces approches sont-elles stylistiques ou y a-t-il des raisons qui rendent une approche meilleure?

Comme pour beaucoup de choses, l'approche correcte dépend de ce que vous essayez de faire pour le bouton spécifique et de ce que vous faites d'autre avec l'activité.

La classe d'activité implémente l'interface :
c'est une bonne option lorsque vous n'avez qu'un seul type de tâche à exécuter lorsque cet écouteur est appelé. Un exemple de ceci serait un formulaire simple avec un certain nombre de champs et un bouton d'enregistrement. Je préfère que mon auditeur d'événements ne vérifie pas la source de l'événement afin de décider ce qui doit réellement être fait. Je sais que certains peuvent dire que c'est une chose de style, mais je crois qu'en n'exigeant pas l'auditeur de faire cette vérification, le code est plus facile à suivre car vous saurez exactement ce qui est appelé pour chaque événement.

Une classe différente implémente l'interface :
comme je l'ai dit ci-dessus, je préfère cette option lorsque j'ai plusieurs éléments qui peuvent déclencher le même événement. En étendant l'exemple ci-dessus, ajoutons un bouton clair qui nécessite également un écouteur de clics. Créez un écouteur qui exécute les actions de sauvegarde et un autre qui exécute les actions claires. Chaque écouteur n'est ajouté qu'aux composants qui produiront cette action.

Cette implémentation présente un avantage supplémentaire que vous pouvez utiliser si vous le souhaitez. L'avantage est qu'il empêche d'autres classes de déclencher l'événement à l'intérieur de votre classe d'activité. Étant donné que la méthode d'interface doit être publique, toute personne ayant une référence à la classe peut déclencher l'événement. Si vous voulez un contrôle fin sur qui peut faire quoi dans l'application, une classe distincte empêche quiconque ayant une référence à l'activité de déclencher l'effacement ou l'enregistrement de votre formulaire (ou potentiellement de casser le code si l'auditeur utilise la source, mais ne le fait pas). pas gérer une mauvaise entrée).

Une classe interne anonyme implémente l'interface :
C'est vraiment juste une façon spécifique de construire la deuxième option d'utiliser une classe différente comme implémentation. Cette option peut même restreindre encore plus qui a accès pour déclencher l'événement car personne d'autre ne peut créer une instance de la classe. Cependant, je pense que le facteur le plus important entre les deux options est la quantité de travail en cours. Effacer quelques champs de texte est une opération simple et directe. Cependant, le processus d'enregistrement du for peut impliquer un certain nombre de tâches si vous validez l'entrée (ce que vous devriez faire), écrivez dans une base de données pour stocker les valeurs et déclenchez une action de post-sauvegarde. Dans ce cas, créer une classe distincte avec son propre fichier fournira une division plus claire entre le formulaire d'entrée et le traitement des données. Cela à son tour conserve le code du formulaire au lieu d'un fichier plus grand avec plusieurs classes internes imbriquées à l'intérieur.

Une quatrième façon consiste à définir l'attribut onClick dans la présentation:

<Button android:onClick="clickHandlerForButtonX" />

qui a cette méthode correspondante dans l'activité:

public void clickHandlerForButtonX(View v) {
    //Handle Button X here
}