Pourquoi les opérateurs d'affectation composés + =, - =, * =, / = de Java ne nécessitent-ils pas de transtypage?

Jusqu'à aujourd'hui, je pensais que par exemple:

i += j;

Était juste un raccourci pour:

i = i + j;

Mais si nous essayons ceci:

int i = 5;
long j = 8;

Alors i = i + j;ne compilera pas mais i += j;compilera bien.

Cela signifie-t-il qu'il s'agit en fait d' i += j;un raccourci pour quelque chose comme ça i = (type of i) (i + j)?

Comme toujours avec ces questions, le JLS détient la réponse. Dans ce cas, §15.26.2 Opérateurs d'affectation composée . Un extrait:

Une expression d'affectation composée du formulaire E1 op= E2est équivalente à E1 = (T)((E1) op (E2)), où Test le type de E1, sauf qu'elle E1n'est évaluée qu'une seule fois.

Un exemple cité du §15.26.2

[...] le code suivant est correct:

short x = 3;
x += 4.6;

et se traduit par x ayant la valeur 7 car il est équivalent à:

short x = 3;
x = (short)(x + 4.6);

En d'autres termes, votre hypothèse est correcte.

Un bon exemple de ce casting utilise * = ou / =

byte b = 10;
b *= 5.7;
System.out.println(b); // prints 57

ou

byte b = 100;
b /= 2.5;
System.out.println(b); // prints 40

ou

char ch = '0';
ch *= 1.1;
System.out.println(ch); // prints '4'

ou

char ch = 'A';
ch *= 1.5;
System.out.println(ch); // prints 'a'

Très bonne question. La spécification du langage Java confirme votre suggestion.

Par exemple, le code suivant est correct:

short x = 3;
x += 4.6;

et se traduit par x ayant la valeur 7 car il est équivalent à:

short x = 3;
x = (short)(x + 4.6);

Oui,

essentiellement quand on écrit

i += l; 

le compilateur convertit cela en

i = (int)(i + l);

Je viens de vérifier le .classcode du fichier.

Vraiment une bonne chose à savoir

vous devez convertir de longà int explicitlydans le cas où i = i + l il compilera et donnera une sortie correcte. comme

i = i + (int)l;

ou

i = (int)((long)i + l); // this is what happens in case of += , dont need (long) casting since upper casting is done implicitly.

mais dans ce cas, +=cela fonctionne très bien, car l'opérateur effectue implicitement le transtypage de type de variable droite en type de variable gauche, il n'est donc pas nécessaire de transtyper explicitement.

Le problème ici concerne la conversion de type.

Lorsque vous ajoutez int et long,

1. L'objet int est converti en long et les deux sont ajoutés et vous obtenez un objet long.
2. mais un objet long ne peut pas être implicitement converti en int. Donc, vous devez le faire explicitement.

Mais il +=est codé de telle manière qu'il tape du casting.i=(int)(i+m)

En Java, les conversions de type sont effectuées automatiquement lorsque le type de l'expression sur le côté droit d'une opération d'affectation peut être promu en toute sécurité au type de la variable sur le côté gauche de l'affectation. Ainsi, nous pouvons sans risque attribuer:

 octet -> court -> int -> long -> float -> double. 

La même chose ne fonctionnera pas dans l'autre sens. Par exemple, nous ne pouvons pas convertir automatiquement un long en un entier car le premier nécessite plus de stockage que le second et par conséquent des informations peuvent être perdues. Pour forcer une telle conversion, nous devons effectuer une conversion explicite.
Type - Conversion

Parfois, une telle question peut être posée lors d'un entretien.

Par exemple, lorsque vous écrivez:

int a = 2;
long b = 3;
a = a + b;

il n'y a pas de transtypage automatique. En C ++, il n'y aura pas d'erreur lors de la compilation du code ci-dessus, mais en Java, vous obtiendrez quelque chose comme Incompatible type exception.

Donc, pour l'éviter, vous devez écrire votre code comme ceci:

int a = 2;
long b = 3;
a += b;// No compilation error or any exception due to the auto typecasting

La principale différence est qu'avec a = a + b, il n'y a pas de transtypage en cours, et donc le compilateur se fâche contre vous pour ne pas transtyper. Mais avec a += b, ce qu'il fait vraiment, c'est la conversion ben un type compatible avec a. Donc si tu le fais

int a=5;
long b=10;
a+=b;
System.out.println(a);

Ce que vous faites vraiment, c'est:

int a=5;
long b=10;
a=a+(int)b;
System.out.println(a);

Point subtil ici ...

Il y a un transtypage implicite pour i+jquand jest un double et iest un int. Java convertit TOUJOURS un entier en double lorsqu'il y a une opération entre eux.

Pour clarifier i+=joù iest un entier et jest un double peut être décrit comme

i = <int>(<double>i + j)

Voir: cette description du casting implicite

Vous voudrez peut - être cataloguée jà (int)dans ce cas pour plus de clarté.

La spécification du langage Java définit E1 op= E2comme équivalent à E1 = (T) ((E1) op (E2))où Test un type de E1et E1est évaluée une fois .

C'est une réponse technique, mais vous vous demandez peut-être pourquoi c'est un cas. Eh bien, considérons le programme suivant.

public class PlusEquals {
    public static void main(String[] args) {
        byte a = 1;
        byte b = 2;
        a = a + b;
        System.out.println(a);
    }
}

Qu'est-ce que ce programme imprime?

Avez-vous deviné 3? Dommage, ce programme ne se compilera pas. Pourquoi? Eh bien, il se trouve que l'ajout d'octets en Java est défini pour renvoyer unint . Je pense que cela est dû au fait que la machine virtuelle Java ne définit pas d'opérations d'octets pour économiser sur les bytecodes (il y en a un nombre limité, après tout), l'utilisation d'opérations entières à la place est un détail d'implémentation exposé dans un langage.

Mais si a = a + bcela ne fonctionne pas, cela signifierait a += bqu'il ne fonctionnerait jamais pour les octets s'il E1 += E2était défini comme tel E1 = E1 + E2. Comme le montre l'exemple précédent, ce serait effectivement le cas. En tant que hack pour faire +=fonctionner l'opérateur pour les octets et les courts métrages, il y a une distribution implicite impliquée. Ce n'est pas un hack génial, mais au cours du travail Java 1.0, l'accent était mis sur la sortie du langage pour commencer. Maintenant, en raison de la compatibilité descendante, ce hack introduit dans Java 1.0 n'a pas pu être supprimé.