Programmation en Java – Les opérateurs
Java fournit un ensemble d’opérateurs pour manipuler des variables. Nous pouvons les diviser en des groupes comme suit:
- Opérateurs arithmétiques
- Opérateurs relationnels
- Opérateurs logiques
- Opérateurs bit à bit
- Opérateurs d’affectation
- Autres opérateurs
Dans ce chapitre, nous allons voir le fonctionnement de chaque opérateur.
Opérateurs arithmétiques
Le tableau suivant présente tous les opérateurs arithmétiques supportés par le langage Java. Supposons que la variable A contenant la valeur 10 et que la variable B contenant la valeur 20.
Opérateur | Description | Exemple |
---|---|---|
+ | La somme | A + B = 30 |
− | La soustraction | A − B = 10 |
∗ | La multiplication | A ∗ B = 200 |
∕ | La division | B ∕ A = 2 |
% | Modulo c’est le reste d’une division entier. | B % A = 0 |
++ | Opérateur d’incrémentation qui consiste à ajouter 1 à une variable. | A++ = 11 |
— | Opérateur de décrémentation qui consiste à retirer 1 à une variable. | A– = 9 |
Exemple
Essayez l’exemple suivant pour comprendre tous les opérateurs arithmétiques disponibles dans Java
public class ClassTest { public static void main(String args[]) { int x = 4; int y = 2; int z = 6; int w = 8; System.out.println("x + y = " + (x + y) ); System.out.println("x - y = " + (x - y) ); System.out.println("x * y = " + (x * y) ); System.out.println("y / x = " + (y / x) ); System.out.println("y % x = " + (y % x) ); System.out.println("z % x = " + (z % x) ); System.out.println("x++ = " + (x++) ); System.out.println("y-- = " + (x--) ); // Vérifier la différence entre w++ et ++w System.out.println("w++ = " + (w++) ); System.out.println("++w = " + (++w) ); } }
Lorsque vous compilez et exécutez le programme ci-dessus, il produit le résultat suivant
x + y = 6 x - y = 2 x * y = 8 y / x = 0 y % x = 2 z % x = 2 x++ = 4 y-- = 5 w++ = 8 ++w = 10
Opérateurs relationnels
Le tableau suivant montre tous les opérateurs relationnels supportés par Java. Supposons que la variable A contenant la valeur 10 et la variable B contenant la valeur 20 donc
Opérateur | Description | Exemple |
---|---|---|
== | Vérifie si les deux opérandes sont égales ou non. Si oui, alors la condition est true. | (A == B) est False. |
!= | Vérifie si les deux opérandes sont égales ou non. Si les valeurs ne sont pas égales, la condition est True. | (A != B) est True. |
> | Vérifie si la valeur de l’opérande gauche est supérieure à la valeur de l’opérande droit. Si oui, alors la condition devient True. | (A > B) est False. |
< | Vérifie si la valeur de l’opérande gauche est inférieure à la valeur de l’opérande droit. Si oui, alors la condition devient True. | (A < B) est True. |
>= | Vérifie si la valeur de l’opérande gauche est supérieure ou égale à la valeur de l’opérande droit. Si oui, alors la condition devient True. | (A >= B) est False. |
<= | Vérifie si la valeur de l’opérande gauche est inférieure ou égale à la valeur de l’opérande droit. Si oui, alors la condition devient True. | (A <= B) est True. |
Exemple
Essayez l’exemple suivant pour comprendre tous les opérateurs relationnels disponibles en Java
public class ClassTest { public static void main(String args[]) { int x = 10; int y = 20; System.out.println("x == y = "+ (x == y) ); System.out.println("x != y = "+ (x != y) ); System.out.println("x > y = "+ (x > y) ); System.out.println("x < y = "+ (x < y) ); System.out.println("y >= x = "+ (y >= x) ); System.out.println("y <= x = "+ (y <= x) ); } }
Lorsque vous compilez et exécutez le programme ci-dessus, il produit le résultat suivant
x == y = false x != y = true x > y = false x < y = true y >= x = true y <= x = false
Opérateurs logiques
Le tableau suivant montre tous les opérateurs logiques pris en charge par le langage Java. Supposons que la variable A contenant la valeur 1 et la variable B contenant la valeur 0.
Opérateur | Description | Exemple |
---|---|---|
&& | Opérateur logique AND. Si les deux opérandes ne sont pas égaux à zéro, la condition devient True. | (A && B) est False. |
|| | Opérateur logique OR. Si l’un des deux opérandes est non nul, la condition devient True. | (A || B) est True. |
! | Opérateur logique NOT. Il est utilisé pour inverser l’état logique de son opérande. Si une condition est True, l’opérateur NOT le rendra False. | !(A && B) est True. |
Exemple
Essayez l’exemple suivant pour comprendre tous les opérateurs logiques disponibles dans Java
public class ClassTest { public static void main(String args[]) { boolean x = true; boolean y = false; System.out.println("x && y = " + (x&&y)); System.out.println("x || y = " + (x||y) ); System.out.println("!(x && y) = " + !(x && y)); } }
Lorsque vous compilez et exécutez le programme ci-dessus, il produit le résultat suivant
x && y = false x || y = true !(x && y) = true
Opérateurs bit à bit
L’opérateur bit à bit fonctionne sur les bits et exécute l’opération bit par bit. Les tables de vérité pour &, | , et ^ sont les suivantes
p | q | p & q | p | q | p ^ q |
---|---|---|---|---|
0 | 0 | 0 | 0 | 0 |
0 | 1 | 0 | 1 | 1 |
1 | 1 | 1 | 1 | 0 |
1 | 0 | 0 | 1 | 1 |
Supposons A = 60 et B = 13 en format binaire, ils seront comme suit –
A = 0011 1100
B = 0000 1101
—————–
A & B = 0000 1100
A | B = 0011 1101
A ^ B = 0011 0001
~ A = 1100 0011
Essayez l’exemple suivant pour comprendre tous les opérateurs bit à bit disponibles dans Java
public class ClassTest { public static void main(String args[]) { int x = 60; // 60 = 0011 1100 int y = 13; // 13 = 0000 1101 int z = 0; z = x & y; // 12 = 0000 1100 System.out.println("x & y = " + z ); z = x | y; // 61 = 0011 1101 System.out.println("x | y = " + z ); z = x ^ y; // 49 = 0011 0001 System.out.println("x ^ y = " + z ); z = ~x; //-61 = 1100 0011 System.out.println("~x = " + z ); z = x << 2; // 240 = 1111 0000 System.out.println("x << 2 = " + z ); z = x >> 2; // 15 = 1111 System.out.println("x >> 2 = " + z ); z = x >>> 2; // 15 = 0000 1111 System.out.println("x >>> 2 = " + z ); } }
Lorsque vous compilez et exécutez le programme ci-dessus, il produit le résultat suivant
x & y = 12 x | y = 61 x ^ y = 49 ~x = -61 x << 2 = 240 x >> 2 = 15 x >>> 2 = 15
Opérateurs d’affectation
Le tableau suivant représente les opérateurs d’affectation pris en charge par le langage Java
Opérateur | Description | Exemple |
---|---|---|
= | Opérateur d’affectation simple. Affecte les valeurs des opérandes de droite à l’opérande de gauche | C = A + B assignera la valeur de A + B à C |
+= | Il ajoute l’opérande droit à l’opérande gauche et affecte le résultat à l’opérande gauche. | C += A est équivalent à C = C + A |
-= | Il soustrait l’opérande droit de l’opérande gauche et affecte le résultat à l’opérande gauche. | C -= A est équivalent à C = C – A |
*= | Il multiplie l’opérande droit par l’opérande gauche et attribue le résultat à l’opérande gauche. | C *= A est équivalent à C = C * A |
/= | Il divise l’opérande gauche par l’opérande droit et affecte le résultat à l’opérande gauche. | C /= A est équivalent à C = C / A |
%= | Il prend le modulo en utilisant deux opérandes et attribue le résultat à l’opérande gauche. | C %= A est équivalent à C = C % A |
<<= | Opérateur de décalage à gauche. | C <<= 2 est identique à C = C << 2 |
>>= | Opérateur de décalage à droite | C >>= 2 est identique à C = C >> 2 |
&= | Opérateur bit à bit. | C &= 2 est identique à C = C & 2 |
^= | Opérateur OU exclusif bit à bit. | C ^= 2 est identique à C = C ^ 2 |
|= | Opérateur OU inclusive bit à bit. | C |= 2 est identique à C = C | 2 |
Exemple
Essayez l’exemple suivant pour comprendre tous les opérateurs d’affectation disponibles en Java
public class ClassTest { public static void main(String args[]) { int x = 10; int y = 20; int z = 0; z = x + y; System.out.println("z = x + y = " + z ); z += x ; System.out.println("z += x = " + z ); z -= x ; System.out.println("z -= x = " + z ); z *= x ; System.out.println("z *= x = " + z ); x = 10; z = 15; z /= x ; System.out.println("c /= x = " + z ); x = 10; z = 15; z %= x ; System.out.println("z %= x = " + z ); z <<= 2 ; System.out.println("z <<= 2 = " + z ); z >>= 2 ; System.out.println("z >>= 2 = " + z ); z >>= 2 ; System.out.println("z >>= 2 = " + z ); z &= x ; System.out.println("z &= x = " + z ); z ^= x ; System.out.println("z ^= x = " + z ); z |= x ; System.out.println("z |= x = " + z ); } }
Lorsque vous compilez et exécutez le programme ci-dessus, il produit le résultat suivant
z = x + y = 30 z += x = 40 z -= x = 30 z *= x = 300 c /= x = 1 z %= x = 5 z <<= 2 = 20 z >>= 2 = 5 z >>= 2 = 1 z &= x = 0 z ^= x = 10 z |= x = 10
Opérateur ternaire
Outre les opérateurs examinés ci-dessus, il existe quelques autres opérateurs importants dont sizeof et ? : sont pris en charge par le langage Java.
Opérateur | Description | Exemple |
---|---|---|
? : | Expression conditionnelle. | If Condition est True ? donc la valeur X : sinon la valeur Y |
Essayez l’exemple suivant :
public class ClassTest { public static void main(String args[]) { int x, y; x = 10; y = (x == 1) ? 20: 30; System.out.println( "La valeur de y est:" + y ); y = (x == 10) ? 20: 30; System.out.println( "La valeur de y est:" + y ); } }
Lorsque vous compilez et exécutez le programme ci-dessus, il produit le résultat suivant
La valeur de y est: 30 La valeur de y est: 20