Opérateurs Java

L'une des utilisations les plus élémentaires des ordinateurs est d'effectuer des opérations mathématiques. En tant que langage informatique, Java fournit également un riche ensemble d'opérateurs pour manipuler des variables. Nous pouvons répartir les opérateurs dans les groupes suivants :

  • Opérateurs arithmétiques
  • Opérateurs relationnels
  • Opérateurs bit à bit
  • Opérateurs logiques
  • Opérateurs d'affectation
  • Autres opérateurs

Opérateurs arithmétiques

Les opérateurs arithmétiques sont utilisés dans les expressions mathématiques, et leur fonction est la même qu'en mathématiques. Le tableau suivant liste tous les opérateurs arithmétiques.

Dans les exemples du tableau, on suppose que la variable entière A a la valeur 10 et que la variable B a la valeur 20 :

Operator Description Exemple
+ Addition - ajoute les valeurs de chaque côté de l'opérateur A + B est égal à 30
- Soustraction - soustrait l'opérande de droite de l'opérande de gauche A - B est égal à -10
* Multiplication - multiplie les valeurs de chaque côté de l'opérateur A * B est égal à 200
/ Division - divise l'opérande de gauche par l'opérande de droite B / A est égal à 2
％ Reste - le reste de la division de l'opérande de gauche par l'opérande de droite B%A est égal à 0
++ Incrémentation : augmente la valeur de l'opérande de 1 B++ ou ++B est égal à 21 (voir ci-dessous pour la différence)
-- Décrémentation : diminue la valeur de l'opérande de 1 B-- ou --B est égal à 19 (voir ci-dessous pour la différence)

Exemple

Le programme d'exemple simple ci-dessous illustre les opérateurs arithmétiques. Copiez et collez le programme Java suivant, enregistrez-le dans un fichier Test.java, puis compilez et exécutez ce programme :

Exemple

public class Test { public static void main(String[] args) { int a = 10; int b = 20; int c = 25; int d = 25; System.out.println("a + b = " + (a + b) ); System.out.println("a - b = " + (a - b) ); System.out.println("a * b = " + (a * b) ); System.out.println("b / a = " + (b / a) ); System.out.println("b % a = " + (b % a) ); System.out.println("c % a = " + (c % a) ); System.out.println("a++ = " + (a++) ); System.out.println("a-- = " + (a--) ); //Voyez la différence entre d++ et ++d System.out.println("d++ = " + (d++) ); System.out.println("++d = " + (++d) ); } }

Exécuter l'exemple »

Le résultat de la compilation et de l'exécution de l'exemple ci-dessus est le suivant :

a + b = 30
a - b = -10
a * b = 200
b / a = 2
b % a = 0
c % a = 5
a++   = 10
a--   = 11
d++   = 25
++d   = 27

Opérateurs d'incrémentation et de décrémentation

1. Opérateurs d'incrémentation (++) et de décrémentation (--)Ce sont des opérateurs arithmétiques spéciaux. Alors que les opérateurs arithmétiques nécessitent deux opérandes pour effectuer une opération, les opérateurs d'incrémentation et de décrémentation agissent sur un seul opérande.

Exemple

public class selfAddMinus{ public static void main(String[] args){ int a = 3;//Définir une variable; int b = ++a;//Opération d'incrémentation int c = 3; int d = --c;//Opération de décrémentation System.out.println("La valeur après l'opération d'incrémentation est égale à"+b); System.out.println("La valeur après l'opération de décrémentation est égale à"+d); } }

Le résultat est :

进行自增运算后的值等于4
进行自减运算后的值等于2

Explication :

  • int b = ++a; Le processus d'opération se décompose comme suit : a=a+1=4; b=a=4; le résultat final est b=4, a=4

  • int d = --c; Le processus d'opération se décompose comme suit : c=c-1=2; d=c=2; le résultat final est d=2, c=2

2. Incrémentation et décrémentation préfixées (++a, --a) :Effectuez d'abord l'opération d'incrémentation ou de décrémentation, puis évaluez l'expression.

3. Incrémentation et décrémentation postfixées (a++, a--) :Évaluez d'abord l'expression, puis effectuez l'opération d'incrémentation ou de décrémentation. Exemple :

Exemple

public class selfAddMinus{ public static void main(String[] args){ int a = 5;//Définir une variable; int b = 5; int x = 2*++a; int y = 2*b++; System.out.println("Après l'opérateur d'incrémentation préfixe, a="+a+",x="+x); System.out.println("Après l'opérateur d'incrémentation postfixe, b="+b+",y="+y); } }

Le résultat est :

自增运算符前缀运算后a=6，x=12
自增运算符后缀运算后b=6，y=10

Opérateurs relationnels

Le tableau suivant répertorie les opérateurs relationnels pris en charge par Java.

Dans les exemples du tableau, la variable entière A a la valeur 10 et la variable B a la valeur 20 :

Operator Description Exemple
== Vérifie si les valeurs de deux opérandes sont égales ; si elles sont égales, la condition est vraie. (A == B) est faux.
!= Vérifie si les valeurs de deux opérandes sont égales ; si les valeurs ne sont pas égales, la condition est vraie. (A != B) est vraie.
>  Vérifie si la valeur de l'opérande gauche est supérieure à la valeur de l'opérande droit ; si c'est le cas, la condition est vraie. (A > B) est faux.
<  Vérifie si la valeur de l'opérande gauche est inférieure à la valeur de l'opérande droit ; si c'est le cas, la condition est vraie. (A < B) est vraie.
>= Vérifie si la valeur de l'opérande gauche est supérieure ou égale à la valeur de l'opérande droit ; si c'est le cas, la condition est vraie. (A >= B) est faux.
<= Vérifie si la valeur de l'opérande gauche est inférieure ou égale à la valeur de l'opérande droit ; si c'est le cas, la condition est vraie. (A <= B) est vraie.

Exemple

Le programme d'exemple simple ci-dessous illustre les opérateurs relationnels. Copiez et collez le programme Java suivant, enregistrez-le dans un fichier Test.java, puis compilez et exécutez ce programme :

Code du fichier Test.java :

public class Test { public static void main(String[] args) { int a = 10; int b = 20; System.out.println("a == b = " + (a == b) ); System.out.println("a != b = " + (a != b) ); System.out.println("a > b = " + (a > b) ); System.out.println("a < b = " + (a < b) ); System.out.println("b >= a = " + (b >= a) ); System.out.println("b <= a = " + (b <= a) ); } }

Le résultat de la compilation et de l'exécution de l'exemple ci-dessus est le suivant :

a == b = false
a != b = true
a > b = false
a < b = true
b >= a = true
b <= a = false

Opérateurs bit à bit

Java définit des opérateurs bit à bit, qui s'appliquent au type entier (int), au type long (long), au type short (short), au type caractère (char) et au type octet (byte), etc.

Les opérateurs bit à bit agissent sur tous les bits et effectuent les opérations bit par bit. Supposons a = 60, b = 13 ; leur représentation binaire sera la suivante :

A = 0011 1100
B = 0000 1101
-----------------
A&B = 0000 1100
A | B = 0011 1101
A ^ B = 0011 0001
~A= 1100 0011

Le tableau suivant liste les opérations de base des opérateurs bit à bit, en supposant que la variable entière A a la valeur 60 et que la variable B a la valeur 13 :

Operator Description Exemple
＆ Si les bits correspondants sont tous deux à 1, le résultat est 1 ; sinon, il est 0. (A & B) donne 12, soit 0000 1100
| Si les bits correspondants sont tous deux à 0, le résultat est 0 ; sinon, il est 1. (A | B) donne 61, soit 0011 1101
^ Si les valeurs des bits correspondants sont identiques, le résultat est 0 ; sinon, il est 1. (A ^ B) donne 49, soit 0011 0001
〜 L'opérateur de complément bit à bit inverse chaque bit de l'opérande, c'est-à-dire que 0 devient 1 et 1 devient 0. (~A) donne -61, soit 1100 0011
<<  Opérateur de décalage à gauche bit à bit. L'opérande gauche est décalé vers la gauche d'un nombre de bits spécifié par l'opérande droit. A << 2 donne 240, c.-à-d. 1111 0000
>>  Opérateur de décalage à droite bit à bit. L'opérande gauche est décalé vers la droite du nombre de bits spécifié par l'opérande droit. A >> 2 donne 15, c.-à-d. 1111
>>>  Opérateur de décalage à droite bit à bit avec remplissage de zéros. La valeur de l'opérande gauche est décalée vers la droite du nombre de bits spécifié par l'opérande droit, et les bits libérés sont remplis de zéros. A >>> 2 donne 15, c.-à-d. 0000 1111

Exemple

Le programme d'exemple simple ci-dessous illustre les opérateurs bit à bit. Copiez et collez le programme Java suivant, enregistrez-le dans un fichier Test.java, puis compilez et exécutez ce programme :

Code du fichier Test.java :

public class Test {   public static void main(String[] args) {     int a = 60; /* 60 = 0011 1100 */       int b = 13; /* 13 = 0000 1101 */      int c = 0;      c = a & b;       /* 12 = 0000 1100 */      System.out.println("a & b = " + c );      c = a | b;       /* 61 = 0011 1101 */      System.out.println("a | b = " + c );      c = a ^ b;       /* 49 = 0011 0001 */      System.out.println("a ^ b = " + c );      c = ~a;          /*-61 = 1100 0011 */      System.out.println("~a = " + c );      c = a << 2;     /* 240 = 1111 0000 */      System.out.println("a << 2 = " + c );      c = a >> 2;     /* 15 = 1111 */      System.out.println("a >> 2  = " + c );       c = a >>> 2;     /* 15 = 0000 1111 */      System.out.println("a >>> 2 = " + c );   } } 

Le résultat de la compilation et de l'exécution de l'exemple ci-dessus est le suivant :

a & b = 12
a | b = 61
a ^ b = 49
~a = -61
a << 2 = 240
a >> 2  = 15
a >>> 2 = 15

Opérateurs logiques

Le tableau suivant répertorie les opérations de base des opérateurs logiques, en supposant que la variable booléenne A est vraie et que la variable B est fausse.

Operator Description Exemple
&& Appelé opérateur ET logique. La condition est vraie si et seulement si les deux opérandes sont vrais. (A && B) est faux.
| | Appelé opérateur OU logique. Si l'un des deux opérandes est vrai, la condition est vraie. (A || B) est vrai.
！ Appelé opérateur NON logique. Il est utilisé pour inverser l'état logique de l'opérande. Si une condition est vraie, alors l'opérateur NON logique produira faux. !(A && B) est vrai.

Exemple

Le programme d'exemple simple ci-dessous illustre les opérateurs logiques. Copiez et collez le programme Java suivant, enregistrez-le dans un fichier Test.java, puis compilez et exécutez ce programme :

Exemple

public class Test { public static void main(String[] args) { boolean a = true; boolean b = false; System.out.println("a && b = " + (a&&b)); System.out.println("a || b = " + (a||b) ); System.out.println("!(a && b) = " + !(a && b)); } }

Le résultat de la compilation et de l'exécution de l'exemple ci-dessus est le suivant :

a && b = false
a || b = true
!(a && b) = true

Opérateurs logiques à court-circuit

Lors de l'utilisation de l'opérateur ET logique, le résultat n'est vrai que si les deux opérandes sont vrais, mais si le premier opérande est faux, le résultat est nécessairement faux, et le second opérande n'est plus évalué.

Exemple

public class LuoJi{ public static void main(String[] args){ int a = 5;//Définir une variable; boolean b = (a<4)&&(a++<10); System.out.println("Le résultat de l'utilisation de l'opérateur logique à court-circuit est :"+b); System.out.println("Le résultat de a est :"+a); } }

La sortie est :

使用短路逻辑运算符的结果为false
a的结果为5

Analyse :Ce programme utilise l'opérateur logique à court-circuit (&&). D'abord, le résultat de a<4 est déterminé comme faux, donc le résultat de b est nécessairement faux ; par conséquent, la seconde opération a++<10 n'est pas exécutée, donc la valeur de a est 5.

Opérateurs d'affectation

Voici les opérateurs d'affectation pris en charge par le langage Java :

Operator Description Exemple
= Opérateur d'affectation simple : affecte la valeur de l'opérande droit à l'opérande gauche. C = A + B affectera la valeur de A + B à C.
+ = Opérateur d'addition et d'affectation : il additionne les opérandes gauche et droit et affecte le résultat à l'opérande gauche. C += A équivaut à C = C + A
- = Opérateur de soustraction et d'affectation : 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
* = Opérateur de multiplication et d'affectation : il multiplie les opérandes gauche et droit et affecte le résultat à l'opérande gauche. C *= A est équivalent à C = C * A
/ = Opérateur de division et d'affectation : il divise l'opérande gauche par l'opérande droit et affecte le résultat à l'opérande gauche. C /= A, lorsque C et A sont du même type, est équivalent à C = C / A
（％）= Opérateur de modulo et d'affectation : il prend le modulo des opérandes gauche et droit et affecte le résultat à l'opérande gauche. C %= A est équivalent à C = C % A
<< = Opérateur d'affectation de décalage à gauche C <<= 2 est équivalent à C = C << 2
>> = Opérateur d'affectation de décalage à droite C >>= 2 est équivalent à C = C >> 2
＆= Opérateur d'affectation ET bit à bit C &= 2 est équivalent à C = C & 2
^ = Opérateur d'affectation XOR bit à bit C ^= 2 est équivalent à C = C ^ 2
| = Opérateur d'affectation OU bit à bit C |= 2 est équivalent à C = C | 2

Exemple

Le programme d'exemple simple suivant illustre les opérateurs d'affectation. Copiez et collez le programme Java suivant, enregistrez-le dans un fichier Test.java, puis compilez et exécutez ce programme :

Code du fichier Test.java :

public class Test { public static void main(String[] args) { int a = 10; int b = 20; int c = 0; c = a + b; System.out.println("c = a + b = " + c ); c += a ; System.out.println("c += a  = " + c ); c -= a ; System.out.println("c -= a = " + c ); c *= a ; System.out.println("c *= a = " + c ); a = 10; c = 15; c /= a ; System.out.println("c /= a = " + c ); a = 10; c = 15; c %= a ; System.out.println("c %= a  = " + c ); c <<= 2 ; System.out.println("c <<= 2 = " + c ); c >>= 2 ; System.out.println("c >>= 2 = " + c ); c >>= 2 ; System.out.println("c >>= 2 = " + c ); c &= a ; System.out.println("c &= a  = " + c ); c ^= a ; System.out.println("c ^= a   = " + c ); c |= a ; System.out.println("c |= a   = " + c ); } }

Le résultat de la compilation et de l'exécution de l'exemple ci-dessus est le suivant :

c = a + b = 30
c += a  = 40
c -= a = 30
c *= a = 300
c /= a = 1
c %= a  = 5
c <<= 2 = 20
c >>= 2 = 5
c >>= 2 = 1
c &= a  = 0
c ^= a   = 10
c |= a   = 10

Opérateur conditionnel (?:)

L'opérateur conditionnel est aussi appelé opérateur ternaire. Cet opérateur a 3 opérandes et doit évaluer une expression booléenne. Le but principal de cet opérateur est de décider quelle valeur doit être affectée à une variable.

variable x = (expression) ? value if true : value if false

Exemple

Code du fichier Test.java :

public class Test { public static void main(String[] args){ int a , b; a = 10; //Si a est égal à 1, affectez 20 à b ; sinon, affectez-lui 30. b = (a == 1) ? 20 : 30; System.out.println( "La valeur de b est : " + b ); //Si a est égal à 10, affectez 20 à b ; sinon, affectez-lui 30. b = (a == 10) ? 20 : 30; System.out.println( "La valeur de b est : " + b ); } }

Le résultat de la compilation et de l'exécution de l'exemple ci-dessus est le suivant :

Value of b is : 30
Value of b is : 20

Opérateur instanceof

Cet opérateur est utilisé pour opérer sur des instances d'objet, en vérifiant si l'objet est d'un type spécifique (type classe ou type interface).

Le format d'utilisation de l'opérateur instanceof est le suivant :

( Object reference variable ) instanceof  (class/interface type)

Si l'objet référencé par la variable à gauche de l'opérateur est un objet de la classe ou de l'interface à droite de l'opérateur, le résultat est true.

Voici un exemple :

String name = "James";
boolean result = name instanceof String; // 由于 name 是 String 类型，所以返回真

Si l'objet comparé est compatible avec le type de droite, cet opérateur renvoie toujours true.

Regardez l'exemple suivant :

class Vehicle {} public class Car extends Vehicle { public static void main(String[] args){ Vehicle a = new Car(); boolean result = a instanceof Car; System.out.println( result); } }

Le résultat de la compilation et de l'exécution de l'exemple ci-dessus est le suivant :

true

Précédence des opérateurs Java

Lorsque plusieurs opérateurs apparaissent dans une expression, lequel vient en premier ? Cela implique la question de la précédence des opérateurs. Dans une expression à plusieurs opérateurs, une précédence d'opérateurs différente peut conduire à des résultats finaux très différents.

Par exemple, (1+3) + (3+2)*2. Si l'addition est calculée en premier avec la précédence la plus élevée, la réponse est 18 ; si la multiplication est calculée en premier, la réponse est 14.

Autre exemple : x = 7 + 3 * 2 ; ici x vaut 13, et non 20, car l'opérateur de multiplication a une précédence plus élevée que l'opérateur d'addition, donc 3 * 2 est calculé en premier pour obtenir 6, puis 7 est ajouté.

Dans le tableau ci-dessous, les opérateurs ayant la précédence la plus élevée sont en haut, et ceux ayant la précédence la plus faible sont en bas.

Catégorie Operator Associativité
Postfixe () [] . (opérateur point) De gauche à droite
Unaire expr++ expr-- De gauche à droite
Unaire ++expr --expr + - ～ ！ De droite à gauche
Multiplicatif * /％ De gauche à droite
Additif + - De gauche à droite
Décalage >> >>>  <<  De gauche à droite
Relationnel > >= < <=  De gauche à droite
Égalité ==  != De gauche à droite
ET bit à bit ＆ De gauche à droite
OU exclusif bit à bit ^ De gauche à droite
OU bit à bit | De gauche à droite
ET logique && De gauche à droite
OU logique | | De gauche à droite
Conditional ？： De droite à gauche
Affectation = + = - = * = / =％= >> = << =＆= ^ = | = De droite à gauche
Virgule ， De gauche à droite
Autres extensions