Java 10 fournit-il un mot-clé val? Sinon, pourquoi pas?
Java 10 apporte un mot-clé var de type C # pour inférence de type locale .
Mais Java 10 fournit-il également un mot clé val, tout comme trouvé dans Scala ?
val fonctionnerait comme var mais la liaison serait final.
var x = "Hello, world. ";
x = "abc"; // allowed
val y = "Hello, world. ";
y = "abc"; // forbidden
Si ce n'est pas le cas, y a-t-il une raison pour que ce soit le cas?
Il n'y a pas de val dans Java 10, comme indiqué dans JEP 286: Local-Variable Type Inference :
Choix de syntaxe
Il y avait une diversité d'opinions sur la syntaxe. Les deux principaux degrés de liberté sont ici les mots-clés à utiliser (var, auto, etc.) et l'opportunité d'avoir un nouveau formulaire distinct pour les habitants immuables (val, let). Nous avons considéré les options syntaxiques suivantes:
- var x = expr uniquement (comme C #)
- var, plus val pour les habitants immuables (comme Scala, Kotlin)
- var, plus let pour les habitants immuables (comme Swift)
- auto x = expr (comme C++)
- const x = expr (déjà un mot réservé)
- x final = expr (déjà un mot réservé)
- soit x = expr
- def x = expr (comme Groovy)
- x: = expr (comme Go)
Après avoir collecté des données substantielles, var était clairement préféré aux approches Groovy, C++ ou Go. Il y avait une grande diversité d'opinions sur une seconde forme syntaxique pour les habitants immuables (val, let); ce serait un compromis de cérémonie supplémentaire pour une capture supplémentaire de l'intention de conception. Au final, nous avons choisi de ne prendre en charge que
var. Quelques détails sur la justification peuvent être trouvés ici.
Et voici le raisonnement principal:
Je sais que c'est la partie dont les gens se soucient vraiment :) Après avoir longuement examiné les avantages et les inconvénients, il semble y avoir un gagnant évident - var-only. Les raisons de ceci incluent:
Même si ce n'était pas le choix le plus populaire dans l'enquête, c'était clairement le choix avec lequel la plupart des gens étaient d'accord. Beaucoup détestaient var/val; d'autres détestaient var/let. Presque personne ne détestait la var-only.
L'expérience avec C # - qui n'a que var - a montré qu'il s'agit d'une solution raisonnable dans les langages de type Java. Il n'y a pas de vague de demande pour "val" en C #.
La volonté de réduire la cérémonie d'immuabilité est certes bien prise, mais dans ce cas, on pousse du mauvais côté du levier. Là où nous avons besoin d'aide pour l'immuabilité, c'est avec les champs, pas avec les locaux. Mais var/val ne s'applique pas aux champs, et ce ne sera certainement jamais le cas.
Si les frais généraux supplémentaires pour obtenir un contrôle de la mutabilité sur celui de l'inférence de type étaient nuls, il pourrait y avoir un cas plus fort, mais il était clair que beaucoup de gens trouvaient deux mots clés principaux différents comme une distraction qui empêchait leurs yeux de s'installer rapidement sur les choses importantes . Si les noms de variables sont plus importants que les types, ils sont aussi plus importants que les modificateurs de mutabilité.
( Source )
Parce qu'il y a final var pour cela en Java. Si nous avions aussi val, il y aurait deux choses qui signifient la même chose. Ce n'est pas bien. Il ne devrait y avoir qu'une seule façon d'exprimer une chose particulière.