Promotion en Java?

Il n’y a pas d’opérateur + pour l’ byte . Au lieu de cela, les deux opérandes sont promus à int, vous avez donc

 byte = byte + byte ... becomes (widening to find + operator) ... byte = int + int ... becomes (result of + operator) ... byte = int 

… qui échoue alors car il n’y a pas de conversion implicite de int en byte . Vous devez lancer:

 byte a = 1; byte b = 2; byte c = (byte) (a + b); 

Voici les règles actuelles pour la promotion numérique, de la section 5.6.2 du JLS :

Lorsqu’un opérateur applique une promotion numérique binary à une paire d’opérandes, chacun d’entre eux devant indiquer une valeur convertible en un type numérique, les règles suivantes s’appliquent, dans l’ordre, en utilisant la conversion par élargissement (§ 5.1.2) pour convertir les opérandes selon les besoins. :

• Si l’un des opérandes est d’un type de référence, la conversion de déballage (§5.1.8) est effectuée. Alors:
• Si l’un des opérandes est de type double, l’autre est converti en double.
• Sinon, si l’un des opérandes est de type float, l’autre est converti en float.
• Sinon, si l’un des opérandes est de type long, l’autre est converti en long.
• Sinon, les deux opérandes sont convertis en type int.

La réponse correcte concernant la promotion automatique à ‘int’ vous a été fournie.

Il y a une autre remarque à propos de cela: les opérateurs d’affectation composée se comportent comme ils ont un cas de type implicite. Exemple:

 byte b1 = 1; byte b2 = 2; b1 = b1 + b2; // compilation fails b1 += b2; // compilation successful 

A partir de cette question SO et des réponses ci-dessus dues à l’opérateur + arithmétique, les deux opérandes sont convertis en type int .

 byte b1 = 1; byte b2 = 2; byte b3 = b1 + b2; // comstack time error 

Dans le code ci-dessus, la valeur de b1 et b2 sera résolue à l’exécution, donc le compilateur convertira les deux en int avant de résoudre la valeur.

Mais si l’on considère le code suivant,

 final byte b1 = 1; final byte b2 = 2; int b3 = b1 + b2; // constant expression, value resolved at comstack time 

b1 et b2 sont des variables finales et les valeurs seront résolues au moment de la compilation afin que la compilation n’échoue pas.

Je voudrais parler de Promotion en général

Java ne peut évaluer que les expressions arithmétiques dans lesquelles les types d’opérandes sont identiques

Par exemple, dans une expression contenant des valeurs int et doubles, les valeurs int sont promues à des valeurs doubles pour être utilisées dans l’expression.

dans un autre mot

 double someVar = 1 / 2;// someVar = 0 

mais

 double someVar = (double)1 / 2;// someVar = 0.5 

Pourquoi?

• nous utilisons l’ cast operator (double) cast operator pour créer une copie temporary virgule flottante de son opérande "1" (appelée explicit conversion )
• Le calcul consiste maintenant en une valeur à virgule flottante (la double copie temporaire de 1) divisée par le nombre entier 2
• Selon l’instruction ci-dessus, Java effectue une opération appelée promotion (ou conversion implicite), afin que les int values soient promues à double values pour être utilisées in l’expression => l’entier 2 est promu à double
• l’expression est devenue double someVar = 1.0 / 2.0; // someVar= 0.5 double someVar = 1.0 / 2.0; // someVar= 0.5

J’espère que cela vous sera utile, même si cela n’est pas au cœur de la question.