Pourquoi les opérateurs d'affectation composée +=, -=, *= en Java ne nécessitent-ils pas de cast explicite ?

Bonjour à tous ! J'ai récemment commencé à apprendre Java et j'ai rencontré un comportement étrange. Supposons que j'ai ce code : ```java int a = 5; long b = 10L; a = a + b; // Erreur de compilation : incompatible types: possible lossy conversion from long to int ``` Ici, tout est logique — Java exige un cast explicite, car `long` peut être plus grand que `int`. Mais si j'utilise un opérateur composé : ```java int a = 5; long b = 10L; a += b; // Fonctionne sans erreur ! ``` Pourquoi ? Logiquement, `a += b` est la même chose que `a = a + b`. Mais le compilateur accepte la deuxième version sans cast, bien que les types soient les mêmes. Cela me trouble, car je pensais que Java vérifiait strictement les types. Expliquez-moi, s'il vous plaît, quel est le piège ? Y a-t-il des situations où cela peut entraîner une perte de données ou des bugs ? <<>>

Pourquoi les opérateurs d'affectation composée ne nécessitent-ils pas de cast ?

Vous avez raison — à première vue, cela semble violer la typage strict. En réalité, tout est dans la spécification du langage Java.