Pourquoi "int i = 2147483647 + 1 ;" est OK, mais "byte b = 127 + 1 ;" n'est pas compilable ?

Question

Pourquoi est-ce que int i = 2147483647 + 1; OK, mais byte b = 127 + 1; n'est pas compilable ?

Answer 1

Les constantes sont évaluées comme des ints, donc 2147483647 + 1 déborde et vous donne un nouveau int, qui est assignable à int alors que 127 + 1 également évalué comme int est égal à 128 et elle n'est pas cessible à byte .

Answer 2

Le littéral 127 désigne une valeur de type int. Il en va de même pour le littéral 1. La somme de ces deux valeurs est le nombre entier 128. Le problème, dans le second cas, est que vous l'affectez à une variable de type byte. Cela n'a rien à voir avec la valeur réelle des expressions. Il est lié au fait que Java ne prend pas en charge les coercitions (*). Vous devez ajouter un typecast

byte b = (byte)(127 + 1);

et ensuite il compile.

(*) du moins pas du type String-to-integer, float-to-Time, ... Java supporte les coercitions si elles sont, dans un sens, sans perte (Java appelle cela "widening").

Et non, le mot "coercition" n'avait pas besoin d'être corrigé. Il a été choisi très délibérément et correctement. De la source la plus proche (Wikipedia) : "Dans la plupart des langues, le mot coercition est utilisé pour dénoter une implicite conversion, soit lors de la compilation, soit lors de l'exécution" et "En informatique, la conversion de type, le typecasting et la coercition sont différents les moyens de transformer, implicitement ou explicitement, une entité d'un type de données en un autre".

Answer 3

Comme une preuve pour @MByD :

Le code suivant se compile :

byte c = (byte)(127 + 1);

Car bien que l'expression (127 + 1) est int et dépasse le champ d'application de byte le résultat est converti en byte . Cette expression donne -128 .

Answer 4

JLS3 #5.2 Conversion de l'affectation

( variable = expression )

De plus, si l'expression est une expression constante (§15.28) de type byte, short, char ou int :

Une conversion primitive restrictive peut être utilisée si le type de la variable est byte, short ou char, et que la valeur de l'expression constante est représentable dans le type de la variable.

---

Sans cette clause, nous ne serions pas en mesure d'écrire

byte x = 0;
char c = 0;

Mais devons-nous être en mesure de le faire ? Je ne le pense pas. Il y a pas mal de magie dans la conversion entre primitives, il faut être très prudent. Je ferais tout pour écrire

byte x = (byte)0;