Maîtriser les opérateurs Java : Types, syntaxe et exemples pratiques

Opérateurs Java

Dans ce tutoriel, vous apprendrez les différents types d'opérateurs en Java, leur syntaxe et comment les utiliser avec des exemples.

Les opérateurs sont des symboles qui effectuent des opérations sur des variables et des valeurs. Par exemple, + est un opérateur utilisé pour l'addition, tandis que * est aussi un opérateur utilisé pour la multiplication.

Les opérateurs en Java peuvent être classés en 5 types :

1. Opérateurs arithmétiques
2. Opérateurs d'affectation
3. Opérateurs relationnels
4. Opérateurs logiques
5. Opérateurs unaires
6. Opérateurs bitwise

---

1. Opérateurs arithmétiques Java

Les opérateurs arithmétiques sont utilisés pour effectuer des opérations arithmétiques sur des variables et des données. Par exemple,

a + b;

Ici, l'opérateur + est utilisé pour additionner deux variables a et b. De même, il existe divers autres opérateurs arithmétiques en Java.

Opérateur	Opération
+	Addition
-	Soustraction
*	Multiplication
/	Division
%	Opération modulo (reste de la division)

Exemple 1 : Opérateurs arithmétiques

class Main {
    public static void main(String[] args) {
        // déclarer variables
        int a = 12, b = 5;
        // opérateur addition
        System.out.println("a + b = " + (a + b));
        // opérateur soustraction
        System.out.println("a - b = " + (a - b));
        // opérateur multiplication
        System.out.println("a * b = " + (a * b));
        // opérateur division
        System.out.println("a / b = " + (a / b));
        // opérateur modulo
        System.out.println("a % b = " + (a % b));
    }
}

Sortie

a + b = 17
a - b = 7
a * b = 60
a / b = 2
a % b = 2

Dans l'exemple ci-dessus, nous avons utilisé les opérateurs +, - et * pour calculer l'addition, la soustraction et la multiplication.

Opérateur de division /

Notez l'opération a / b dans notre programme. L'opérateur / est l'opérateur de division.

Si nous utilisons l'opérateur de division avec deux entiers, le quotient résultant sera aussi un entier. Et si l'un des opérandes est un nombre à virgule flottante, le résultat sera aussi en virgule flottante.

En Java, (9 / 2) est 4
(9.0 / 2) est 4.5
(9 / 2.0) est 4.5
(9.0 / 2.0) est 4.5

Opérateur modulo %

L'opérateur modulo % calcule le reste. Quand a = 7 est divisé par b = 4, le reste est 3.

Note : L'opérateur % est principalement utilisé avec des entiers.

---

2. Opérateurs d'affectation Java

Les opérateurs d'affectation sont utilisés en Java pour assigner des valeurs aux variables. Par exemple,

int age;
age = 5;

Ici, = est l'opérateur d'affectation. Il assigne la valeur à sa droite à la variable à sa gauche. C'est-à-dire, 5 est assigné à la variable age.

Voyons d'autres opérateurs d'affectation disponibles en Java.

Opérateur	Exemple	Équivalent à
=	a = b;	a = b;
+=	a += b;	a = a + b;
-=	a -= b;	a = a - b;
*=	a *= b;	a = a * b;
/=	a /= b;	a = a / b;
%=	a %= b;	a = a % b;

Exemple 2 : Opérateurs d'affectation

class Main {
    public static void main(String[] args) {
        // créer variables
        int a = 4;
        int var;
        // assigner valeur avec =
        var = a;
        System.out.println("var avec = : " + var);
        // assigner avec +=
        var += a;
        System.out.println("var avec += : " + var);
        // assigner avec *=
        var *= a;
        System.out.println("var avec *= : " + var);
    }
}

Sortie

var avec = : 4
var avec += : 8
var avec *= : 32

---

3. Opérateurs relationnels Java

Les opérateurs relationnels sont utilisés pour vérifier la relation entre deux opérandes. Par exemple,

// vérifier si a est inférieur à b
a < b;

Ici, l'opérateur < est l'opérateur relationnel. Il vérifie si a est inférieur à b ou non.

Il renvoie soit true soit false.

Opérateur	Description	Exemple
==	Est égal à	3 == 5 renvoie false
!=	N'est pas égal à	3 != 5 renvoie true
>	Supérieur à	3 > 5 renvoie false
<	Inférieur à	3 < 5 renvoie true
>=	Supérieur ou égal à	3 >= 5 renvoie false
<=	Inférieur ou égal à	3 <= 5 renvoie true

Exemple 3 : Opérateurs relationnels

class Main {
    public static void main(String[] args) {
        // créer variables
        int a = 7, b = 11;
        // valeur de a et b
        System.out.println("a is " + a + " and b is " + b);
        // opérateur ==
        System.out.println(a == b); // false
        // opérateur !=
        System.out.println(a != b); // true
        // opérateur >
        System.out.println(a > b); // false
        // opérateur <
        System.out.println(a < b); // true
        // opérateur >=
        System.out.println(a >= b); // false
        // opérateur <=
        System.out.println(a <= b); // true
    }
}

Note : Les opérateurs relationnels sont utilisés dans la prise de décision et les boucles.

---

4. Opérateurs logiques Java

Les opérateurs logiques sont utilisés pour vérifier si une expression est true ou false. Ils sont utilisés dans la prise de décision.

Opérateur	Exemple	Signification
&& (ET logique)	expression1 && expression2	true seulement si expression1 et expression2 sont true
|| (OU logique)	expression1 || expression2	true si soit expression1 ou expression2 est true
! (NON logique)	!expression	true si expression est false et vice versa

Exemple 4 : Opérateurs logiques

class Main {
    public static void main(String[] args) {
        // opérateur &&
        System.out.println((5 > 3) && (8 > 5)); // true
        System.out.println((5 > 3) && (8 < 5)); // false
        // opérateur ||
        System.out.println((5 < 3) || (8 > 5)); // true
        System.out.println((5 > 3) || (8 < 5)); // true
        System.out.println((5 < 3) || (8 < 5)); // false
        // opérateur !
        System.out.println(!(5 == 3)); // true
        System.out.println(!(5 > 3)); // false
    }
}

Fonctionnement du programme

• (5 > 3) && (8 > 5) renvoie true car both (5 > 3) et (8 > 5) sont true.
• (5 > 3) && (8 < 5) renvoie false car l'expression (8 < 5) est false.
• (5 < 3) || (8 > 5) renvoie true car l'expression (8 > 5) est true.
• (5 > 3) && (8 > 5) renvoie true car l'expression (5 > 3) est true.
• (5 > 3) && (8 > 5) renvoie false car both (5 < 3) et (8 < 5) sont false.
• !(5 == 3) renvoie true car 5 == 3 est false.
• !(5 > 3) renvoie false car 5 > 3 est true.

---

5. Opérateurs unaires Java

Les opérateurs unaires sont utilisés avec un seul opérande. Par exemple, ++ est un opérateur unaire qui augmente la valeur d'une variable de 1. C'est-à-dire, ++5 renverra 6.

Différents types d'opérateurs unaires :

Opérateur	Signification
+	Plus unaire : pas nécessaire car les nombres sont positifs sans l'utiliser
-	Moins unaire : inverse le signe d'une expression
++	Opérateur d'incrémentation : incrémente la valeur de 1
--	Opérateur de décrémentation : décrémente la valeur de 1
!	Opérateur de complément logique : inverse la valeur d'un booléen

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

Java fournit également les opérateurs d'incrémentation et décrémentation : ++ et -- respectivement. ++ augmente la valeur de l'opérande de 1, tandis que -- la diminue de 1. Par exemple,

int num = 5;
// augmenter num de 1
++num;

Ici, la valeur de num passe à 6 depuis sa valeur initiale de 5.

---

Exemple 5 : Opérateurs d'incrémentation et décrémentation

class Main {
    public static void main(String[] args) {
        // déclarer variables
        int a = 12, b = 12;
        int result1, result2;
        // valeur originale
        System.out.println("Valeur de a : " + a);
        // opérateur d'incrémentation
        result1 = ++a;
        System.out.println("Après incrémentation : " + result1);
        System.out.println("Valeur de b : " + b);
        // opérateur de décrémentation
        result2 = --b;
        System.out.println("Après décrémentation : " + result2);
    }
}

Sortie

Valeur de a : 12
Après incrémentation : 13
Valeur de b : 12
Après décrémentation : 11

Dans le programme ci-dessus, nous avons utilisé les opérateurs ++ et -- comme préfixes (++a, --b). Nous pouvons aussi les utiliser comme postfixes (a++, b++).

Il y a une légère différence quand ces opérateurs sont utilisés comme préfixe versus postfixe.

Pour en savoir plus sur ces opérateurs, visitez opérateurs d'incrémentation et décrémentation.

---

6. Opérateurs bitwise Java

Les opérateurs bitwise en Java sont utilisés pour effectuer des opérations sur des bits individuels. Par exemple,

Opération de complément bitwise de 35
35 = 00100011 (En binaire)
~ 00100011
________
11011100 = 220 (En décimal)

Ici, ~ est un opérateur bitwise. Il inverse la valeur de chaque bit (0 à 1 et 1 à 0).

Les divers opérateurs bitwise présents en Java sont :

Opérateur	Description
~	Complément bitwise
<<	Décalage vers la gauche
>>	Décalage vers la droite
>>>	Décalage vers la droite non signé
&	ET bitwise
^	OU exclusif bitwise

Ces opérateurs ne sont généralement pas beaucoup utilisés en Java. Pour en savoir plus, visitez Opérateurs bitwise et de décalage en Java.

---

Autres opérateurs

En plus de ces opérateurs, il existe d'autres opérateurs supplémentaires en Java.

Opérateur instanceof Java

L'opérateur instanceof vérifie si un objet est une instance d'une classe particulière. Par exemple,

class Main {
    public static void main(String[] args) {
        String str = "Programiz";
        boolean result;
        // vérifie si str est une instance de
        // la classe String
        result = str instanceof String;
        System.out.println("Est-ce que str est un objet de String ? " + result);
    }
}

Sortie

Est-ce que str est un objet de String ? true

Ici, str est une instance de la classe String. Donc, l'opérateur instanceof renvoie true. Pour en savoir plus, visitez Java instanceof.

---

Opérateur ternaire Java

L'opérateur ternaire (opérateur conditionnel) est une abréviation pour l'instruction if-then-else. Par exemple,

variable = Expression ? expression1 : expression2

Voici comment cela fonctionne.

• Si l'Expression est true, expression1 est assignée à la variable.
• Si l'Expression est false, expression2 est assignée à la variable.

Voyons un exemple d'opérateur ternaire.

class Java {
    public static void main(String[] args) {
        int februaryDays = 29;
        String result;
        // opérateur ternaire
        result = (februaryDays == 28) ? "Pas une année bissextile" : "Année bissextile";
        System.out.println(result);
    }
}

Sortie

Année bissextile

Dans l'exemple ci-dessus, nous avons utilisé l'opérateur ternaire pour vérifier si l'année est bissextile ou non. Pour en savoir plus, visitez l'opérateur ternaire Java.

---

Maintenant que vous connaissez les opérateurs Java, il est temps de connaître l'ordre dans lequel les opérateurs sont évalués. Pour en savoir plus, visitez Priorité des opérateurs Java.