Opérateurs composés Java

1. Vue d’ensemble

Dans ce tutoriel, nous examinerons les opérateurs composés Java, leurs types et leur évaluation par Java.

Nous expliquerons également comment fonctionne le casting implicite.

2. Opérateurs d’assignation composés

Un opérateur d’affectation est un opérateur binaire qui assigne le résultat du côté droit à la variable du côté gauche. Le plus simple est l’opérateur “=” :

int x = 5;

Cette instruction déclare une nouvelle variable x , attribue à x la valeur de 5 et renvoie 5 .

Les opérateurs d’affectation composée constituent un moyen plus court d’appliquer une opération arithmétique ou binaire et d’affecter la valeur de l’opération à la variable située à gauche. **

Par exemple, les deux instructions de multiplication suivantes sont équivalentes, ce qui signifie que a et b auront la même valeur:

int a = 3, b = 3, c = -2;
a = a **  c;//Simple assignment operator
b ** = c;//Compound assignment operator

Il est important de noter que la variable située à gauche d’un opérateur d’affectation composée doit déjà être déclarée. En d’autres termes, les opérateurs composés ne peuvent pas être utilisés pour déclarer une nouvelle variable.

À l’instar de l’opérateur d’affectation «=», les opérateurs composés renvoient le résultat attribué de l’expression:

long x = 1;
long y = (x+=2);

X et y auront la valeur 3 .

L’affectation (x = 2) fait deux choses: premièrement, elle ajoute 2 à la valeur de la variable x , qui devient 3; ensuite, elle renvoie la valeur de l’affectation, qui est également 3 .

3. Types d’opérateurs d’assignation composés

Java prend en charge 11 opérateurs d’assignation composés. Nous pouvons les regrouper en opérateurs arithmétiques et bits.

Passons en revue les opérateurs arithmétiques et les opérations qu’ils effectuent:

Incrémentation: =
Décrémentation: - =
Multiplication: ** =
Division: /=
Module: % =

Ensuite, nous avons aussi les opérateurs de bits:

ET, binaire: __
OU exclusif, binaire: ^ =
OU inclusif, binaire: | =
Maj gauche, binaire: << =
Décalage à droite, binaire: >> =
Décalage vers la droite zéro: >>> =

Voyons quelques exemples de ces opérations:

----//Simple assignment
int x = 5;//x is 5
//Incrementation
x += 5;//x is 10
//Decrementation
x -= 2;//x is 8
//Multiplication
x ** = 2;//x is 16
//Modulus
x %= 3;//x is 1
//Binary AND
x &= 4;//x is 0
//Binary exclusive OR
x ^= 4;//x is 4
//Binary inclusive OR
x |= 8;//x is 12
----

Comme on peut le voir ici, la syntaxe d’utilisation de ces opérateurs est cohérente.

4. Évaluation des opérations d’assignation composée

Java évalue les opérations composées de deux manières.

Tout d’abord, lorsque l’opérande de gauche n’est pas un tableau, alors Java sera, dans l’ordre:

Vérifier que l’opérande est une variable déclarée
Sauvegarder la valeur de l’opérande gauche
Évaluer l’opérande de droite
Effectuer l’opération binaire indiquée par l’opérateur composé
Convertir le résultat de l’opération binaire en type de

variable de gauche (casting implicite) . Affecter le résultat converti à la variable de gauche

Ensuite, lorsque l’opérande de gauche est un tableau , les étapes à suivre sont un peu différentes:

Vérifiez l’expression de tableau sur le côté gauche et jetez un

NullPointerException ou ArrayIndexOutOfBoundsException si c’est Incorrect . Enregistrer l’élément de tableau dans l’index

Évaluer l’opérande de droite
Vérifier si le composant de tableau sélectionné est un type primitif ou une référence

tapez puis suivez les mêmes étapes que pour la première liste, comme si l’opérande de gauche était une variable.

Si une étape de l’évaluation échoue, Java ne continue pas à exécuter les étapes suivantes.

Donnons quelques exemples liés à l’évaluation de ces opérations à un élément de tableau: **

int[]numbers = null;
//Trying Incrementation
numbers[2]+= 5;

Comme on pouvait s’y attendre, cela lancera une NullPointerException .

Cependant, si nous assignons une valeur initiale au tableau:

int[]numbers = {0, 1};
//Trying Incrementation
numbers[2]+= 5;

Nous nous débarrasserions de NullPointerException, , mais nous n’aurions toujours pas de ArrayIndexOutOfBoundsException , car l’index utilisé n’est pas correct.

Si nous corrigeons cela, l’opération sera complétée avec succès:

int[]numbers = {0, 1};
//Incrementation
numbers[1]+= 5;//x is now 6

Enfin, la variable x sera 6 à la fin de l’affectation.

5. Casting implicite

Une des raisons pour lesquelles les opérateurs composés sont utiles est qu’ils offrent non seulement un moyen plus court pour les opérations, mais également des variables implicitement converties.

Formellement, une expression d’affectation composée de la forme:

E1 op = E2

est équivalent à:

E1 - (T) (E1 sur E2)

où T est le type de E1 .

Considérons l’exemple suivant:

long number = 10;
int i = number;
i = i **  number;//Does not compile

Voyons pourquoi la dernière ligne ne sera pas compilée.

Java promeut automatiquement les types de données plus petits en fichiers plus volumineux lorsqu’ils sont ensemble dans une opération, mais génère une erreur lors de la conversion de types plus volumineux .

Ainsi, d’abord, i sera promu à long et ensuite la multiplication donnera le résultat 10L. Le résultat long sera attribué à i , qui est un int , ce qui jettera une erreur.

Cela pourrait être corrigé avec une distribution explicite:

i = (int) i **  number;

Les opérateurs d’affectation de composé Java sont parfaits dans ce cas car ils effectuent un transtypage implicite: **

i ** = number;

Cette instruction fonctionne très bien, en convertissant le résultat de la multiplication en int et en affectant la valeur à la variable de gauche, i .

6. Conclusion

Dans cet article, nous avons examiné les opérateurs composés en Java, en en donnant quelques exemples et différents types. Nous avons expliqué comment Java évalue ces opérations.

Enfin, nous avons également passé en revue la diffusion implicite, une des raisons pour lesquelles ces opérateurs abrégés sont utiles.

Comme toujours, tous les extraits de code mentionnés dans cet article sont disponibles dans notre référentiel GitHub .

TOC