Pourquoi marquer les variables locales et les paramètres de méthode comme "finaux" en Java?
En Java, vous pouvez qualifier les variables locales et les paramètres de méthode avec le mot-clé final.
public static void foo(final int x) {
final String qwerty = "bar";
}
Sinon, vous ne pourrez pas réaffecter x et qwerty dans le corps de la méthode.
Cette pratique pousse votre code dans le sens de l'immuabilité, ce qui est généralement considéré comme un avantage. Mais, il a également tendance à encombrer le code avec "final" apparaissant partout. Quelle est votre opinion sur le mot-clé final pour les variables locales et les paramètres de méthode en Java?
Vous devriez essayer de le faire chaque fois que cela est approprié. En plus de servir à vous avertir lorsque vous essayez "accidentellement" de modifier une valeur, il fournit des informations au compilateur qui peuvent conduire à une meilleure optimisation du fichier de classe. C'est l'un des points du livre, "Hardcore Java" de Robert Simmons, Jr. En fait, le livre consacre tout son deuxième chapitre à l'utilisation de final pour promouvoir les optimisations et éviter les erreurs logiques. Les outils d'analyse statique tels que PMD et la fonction intégrée SA d'Eclipse signalent ce type de cas pour cette raison.
Mon opinion personnelle est que c'est une perte de temps. Je crois que l'encombrement visuel et la verbosité ajoutée n'en valent pas la peine.
Je n'ai jamais été dans une situation où j'ai réaffecté (rappelez-vous, cela ne rend pas les objets immuables, tout cela signifie que vous ne pouvez pas réaffecter une autre référence à une variable) une variable par erreur.
Mais, bien sûr, c'est une préférence personnelle ;-)
Rendre un paramètre final garantit que la valeur utilisée à n'importe quel endroit de la méthode se réfère à la valeur transmise. Sinon, vous devez analyser mentalement tout le code au-dessus d'un emplacement donné pour savoir quelle valeur le paramètre a à ce point.
Par conséquent, pas en utilisant final rend votre code moins lisible et maintenable, tout seul :)
Les variables locales finales dépendent de l'intention et sont moins importantes à mon avis. Cela dépend de ce qui se passe.
Dans le cas des variables locales, j'ai tendance à éviter cela. Cela provoque un encombrement visuel et n'est généralement pas nécessaire - une fonction doit être suffisamment courte ou se concentrer sur un seul impact pour vous permettre de voir rapidement que vous modifiez quelque chose qui ne devrait pas l'être.
Dans le cas des nombres magiques, je les mettrais comme un champ privé constant de toute façon plutôt que dans le code.
J'utilise uniquement final dans les situations où cela est nécessaire (par exemple, en passant des valeurs à des classes anonymes).
En raison de la nature (parfois) confuse du comportement de Java " passer par référence ", je suis définitivement d'accord avec la finalisation des paramètres var.
La finalisation des var locales semble quelque peu exagérée à l'OMI.
Oui fais le.
Il s'agit de lisibilité. Il est plus facile de raisonner sur les états possibles du programme lorsque vous savez que les variables sont affectées une seule fois.
Une alternative décente consiste à activer l'avertissement IDE lorsqu'un paramètre est affecté ou lorsqu'une variable (autre qu'une variable de boucle) est affectée plusieurs fois.
Bien que cela crée un peu d'encombrement, il vaut la peine de mettre final. Par exemple, Eclipse peut mettre automatiquement le final si vous le configurez pour le faire.
Faire des variables locales et des paramètres de méthode final est essentiel si vous voulez passer ces paramètres dans des classes anonymes - comme vous instanciez un Thread anonyme et souhaitez accéder à ces paramètres dans le corps de la méthode run ().
En dehors de cela, je ne suis pas sûr des avantages de performance avec de meilleures performances grâce à l'optimisation du compilateur. Il appartient à l'implémentation spécifique du compilateur s'il souhaite l'optimiser du tout ...
Il sera bon de connaître les statistiques de performance de l'utilisation de final ...
la finale a trois bonnes raisons:
- les variables d'instance définies par le constructeur ne deviennent immuables
- les méthodes à ne pas remplacer deviennent définitives, utilisez-les avec de vraies raisons, pas par défaut
- les variables ou paramètres locaux à utiliser dans les classes anonymes à l'intérieur d'une méthode doivent être définitifs
Comme les méthodes, les variables et paramètres locaux n'ont pas besoin d'être déclarés définitifs. Comme d'autres l'ont déjà dit, cela encombre le code qui devient moins lisible avec très peu d'effort pour l'optimisation des performances du compilateur, ce n'est pas une vraie raison pour la plupart des fragments de code.
Je laisse Eclipse le faire pour moi lorsqu'ils sont utilisés dans une classe anonyme, ce qui augmente en raison de mon utilisation de l'API Google Collection.
Nous le faisons ici pour les variables locales si nous pensons qu'elles ne seront pas réaffectées ou ne devraient pas être réaffectées.
Les paramètres ne sont pas définitifs car nous avons un Checkstyle-Check qui vérifie la réaffectation des paramètres. Bien sûr, personne ne voudrait jamais réaffecter une variable de paramètre.
Pourquoi voudriez-vous? Vous avez écrit la méthode, donc toute personne qui la modifie peut toujours supprimer le mot clé final de qwerty et le réaffecter. Quant à la signature de la méthode, même raisonnement, bien que je ne sois pas sûr de ce que cela ferait pour les sous-classes de votre classe ... elles peuvent hériter du paramètre final et même si elles remplacent la méthode, être incapables de dé-finaliser x. Essayez-le et découvrez si cela fonctionnerait.
Le seul véritable avantage est donc de rendre le paramètre immuable et qu'il se répercute sur les enfants. Sinon, vous encombrez votre code sans raison particulière. Si cela ne force personne à suivre vos règles, il vaut mieux laisser un bon commentaire pour expliquer pourquoi vous ne devriez pas modifier ce paramètre ou cette variable au lieu de donner le dernier modificateur.
Modifier
En réponse à un commentaire, j'ajouterai que si vous voyez des problèmes de performances, rendre vos variables et paramètres locaux définitifs peut permettre au compilateur d'optimiser mieux votre code. Cependant, du point de vue de l'immuabilité de votre code, je maintiens ma déclaration d'origine.