En Java, dois-je utiliser «final» pour les paramètres et les locales, même si ce n’est pas nécessaire?

Java permet de marquer les variables (champs / variables locales / paramètres) comme final, pour empêcher leur ré-affectation. Je trouve cela très utile avec les champs, car cela m'aide à voir rapidement si certains attributs - ou une classe entière - sont censés être immuables.

D'autre part, je le trouve beaucoup moins utile avec les paramètres locaux et les paramètres, et j'évite en général de les marquer comme finals'ils ne seraient jamais réaffectés (sauf exception évidente lorsqu'ils doivent être utilisés dans une classe interne). . Dernièrement, cependant, je suis tombé sur un code qui utilisait la version finale chaque fois que possible, ce qui, techniquement, fournit davantage d’informations.

N'ayant plus confiance en mon style de programmation, je me demande quels sont les autres avantages et inconvénients de l'application finaln'importe où, quel est le style le plus répandu dans l'industrie et pourquoi.

J'utilise finalla même manière que toi. Pour moi, cela semble superflu pour les variables locales et les paramètres de méthode, et cela ne fournit aucune information supplémentaire utile.

Une chose importante est que je m'efforce de garder mes méthodes courtes et propres , chacune effectuant une tâche unique. Ainsi, mes variables et paramètres locaux ont une portée très limitée et ne sont utilisés que dans un seul but. Cela minimise les chances de les réaffecter par inadvertance.

De plus, comme vous le savez sûrement, finalne garantit pas que vous ne pouvez pas changer la valeur / l’état d’une variable (non primitive). Seulement que vous ne pouvez pas réaffecter la référence à cet objet une fois initialisé. En d'autres termes, cela ne fonctionne de manière transparente qu'avec des variables de type primitif ou immuable. Considérer

final String s = "forever";
final int i = 1;
final Map<String, Integer> m = new HashMap<String, Integer>();

s = "never"; // compilation error!
i++; // compilation error!
m.put(s, i); // fine

Cela signifie que, dans de nombreux cas, cela ne permet toujours pas de comprendre plus facilement ce qui se passe dans le code, et une mauvaise compréhension peut en fait provoquer des bogues subtils difficiles à détecter.

Votre style de programmation Java et vos pensées vont bien - vous n'avez pas besoin de douter de vous-même.

D'autre part, je le trouve beaucoup moins utile avec les paramètres locaux et les paramètres, et j'évite généralement de les marquer comme final, même s'ils ne seront jamais réaffectés (sauf exception évidente lorsqu'ils doivent être utilisés dans une classe interne. ).

C'est exactement pourquoi vous devriez utiliser le finalmot clé. Vous déclarez que VOUS savez qu'il ne sera jamais réaffecté, mais personne d'autre ne le sait. L'utilisation finaldésambiguise immédiatement votre code un tout petit peu plus.

Un des avantages de final/ constlorsque cela est possible est que cela réduit la charge mentale du lecteur de votre code.

Il peut être assuré que la valeur / référence n’est jamais modifiée ultérieurement. Il n'a donc pas besoin de faire attention aux modifications pour comprendre le calcul.

J'ai changé d'avis à ce sujet après avoir appris les langages de programmation purement fonctionnels. Bon Dieu, quel soulagement, si vous pouvez faire confiance à une "variable" pour toujours conserver sa valeur initiale.

Je considère finaldans les paramètres de méthode et les variables locales le code de bruit. Les déclarations de méthodes Java peuvent être assez longues (surtout avec les génériques) - il n'est pas nécessaire de les créer plus longtemps.

Si les tests unitaires sont écrits correctement, l’attribution de paramètres «nocifs» sera prise en compte, il ne devrait donc jamais y avoir de problème. La clarté visuelle est plus importante que d'éviter un bug possible qui n'est pas détecté car la couverture de vos tests unitaires est insuffisante.

Des outils tels que FindBugs et CheckStyle peuvent être configurés pour interrompre la construction si une affectation est faite à des paramètres ou à des variables locales, si de telles choses vous tiennent à coeur.

Bien sûr, si vous devez les rendre finales, par exemple parce que vous utilisez la valeur dans une classe anonyme, alors pas de problème, c'est la solution la plus simple et la plus propre.

Outre l'effet évident d'ajouter des mots-clés supplémentaires à vos paramètres et de les camoufler ainsi à mon humble avis, l'ajout des paramètres de méthode finaux peut souvent rendre le code du corps de la méthode moins lisible, ce qui aggrave le code - d'être "bon", code doit être aussi lisible et aussi simple que possible. Pour un exemple artificiel, disons que j'ai une méthode qui doit fonctionner sans distinction de casse.

Sans final:

public void doSomething(String input) {
    input = input.toLowerCase();
    // do a few things with input
}

Facile. Nettoyer. Tout le monde sait ce qui se passe.

Maintenant avec 'final', option 1:

public void doSomething(final String input) {
    final String lowercaseInput = input.toLowerCase();
    // do a few things with lowercaseInput
}

Bien que définir les paramètres finalempêche le codeur d’ajouter du code parce qu’il pense ne pas travailler avec la valeur originale, il existe un risque équivalent que le code plus bas puisse utiliser à la inputplace lowercaseInput, ce qu’il ne devrait pas et contre lequel on ne peut pas se protéger, car vous pouvez " t le sortir de la portée (ou même assigner nullà inputsi cela pourrait même aider de toute façon).

Avec 'final', option 2:

public void doSomething(final String input) {
    // do a few things with input.toLowerCase()
}

Nous venons tout juste de créer encore plus de bruit de code et d’avoir à invoquer toLowerCase()n fois.

Avec 'final', option 3:

public void doSomething(final String input) {
    doSomethingPrivate(input.toLowerCase());
}

/** @throws IllegalArgumentException if input not all lower case */
private void doSomethingPrivate(final String input) {
    if (!input.equals(input.toLowerCase())) {
        throw new IllegalArgumentException("input not lowercase");
    }
    // do a few things with input
}

Parlez du bruit de code. Ceci est une épave de train. Nous avons une nouvelle méthode, un bloc d'exception requis, car un autre code peut ne pas l'appeler correctement. Plus de tests unitaires pour couvrir l'exception. Tout pour éviter une ligne simple, et à mon humble avis préférable et sans danger,.

Il y a également le problème que les méthodes ne devraient pas être si longues que vous ne pouvez pas facilement les assimiler visuellement et savoir en un coup d'œil qu'une affectation à un paramètre a eu lieu.

Je pense que c’est une bonne pratique / style que, si vous affectez un paramètre, vous le fassiez au début de la méthode, de préférence en première ligne ou juste après la vérification de base des entrées, en le remplaçant efficacement pour toute la méthode, ce qui a un effet cohérent au sein de la méthode. méthode. Les lecteurs savent qu’ils s’attendent à ce que toute tâche soit évidente (à proximité de la déclaration de signature) et dans un endroit cohérent, ce qui atténue considérablement le problème que l’ajout de final tente d’éviter. En fait, j'assigne rarement des paramètres, mais si je le fais, je le fais toujours au sommet d'une méthode.

Notez également que finalne vous protège pas réellement comme cela peut paraître au premier abord:

public void foo(final Date date) {
    date.setTime(0); 
    // code that uses date
}

final ne vous protège pas complètement sauf si le type de paramètre est primitif ou immuable.

Je laisse Eclipse mettre finalavant chaque variable locale, car j’estime que cela facilitera la lecture du programme. Je ne le fais pas avec des paramètres, car je veux garder la liste de paramètres aussi courte que possible, idéalement, elle devrait tenir dans une ligne.