Opérateurs Java :
Maîtrisez tous les opérateurs Java pour effectuer des calculs, des comparaisons et des
opérations logiques dans vos programmes
Qu'est-ce qu'un opérateur en Java ?
Un opérateur Java est un symbole spécial qui effectue une opération (operation) sur
une ou plusieurs valeurs (operands) et produit un résultat (result). Les opérateurs sont
essentiels pour manipuler les données (data) dans vos programmes Java : effectuer des
calculs mathématiques, comparer des valeurs, combiner des conditions ou modifier des
variables.
Le langage Java propose plusieurs catégories d'opérateurs : arithmétiques, de
comparaison (comparison), logiques (logical), d'affectation (assignment), bit à bit
(bitwise) et autres opérateurs spéciaux. Maîtriser ces opérateurs est fondamental pour
tout développeur Java, qu'il soit débutant ou confirmé.
Opérateurs arithmétiques en Java
Les opérateurs arithmétiques permettent d'effectuer des calculs mathématiques
(mathematical operations) sur des valeurs numériques. Ces opérateurs fonctionnent avec
tous les types primitifs numériques (int, double, float, long, etc.).
Opérateur Description Exemple Résultat
+ Addition 10 + 5 15
- Soustraction 10 - 5 5
* Multiplication 10 * 5 50
/ Division 10 / 5 2
% Modulo (reste) 10 % 3 1
public class OperateursArithmetiques {
public static void main(String[] args) {
int a = 10;
int b = 3;
// Opérations arithmétiques de base
int addition = a + b; // 13
int soustraction = a - b; // 7
int multiplication = a * b; // 30
int division = a / b; // 3 (division entière)
int modulo = a % b; // 1 (reste de 10/3)
[Link]("Addition: " + addition);
[Link]("Soustraction: " + soustraction);
[Link]("Multiplication: " + multiplication);
[Link]("Division: " + division);
[Link]("Modulo: " + modulo);
// Division avec décimales
double x = 10.0;
double y = 3.0;
double divisionDecimale = x / y; // 3.333...
[Link]("Division décimale: " + divisionDecimale);
}
}
Attention : La division entre deux entiers (int) en Java produit un résultat entier. Par
exemple, 10 / 3 donne 3, pas 3.33. Pour obtenir un résultat décimal,
utilisez double ou float.
Opérateur modulo (%) en Java
L'opérateur modulo % retourne le reste d'une division entière. Il est très utile pour
vérifier la parité d'un nombre, effectuer des rotations ou créer des cycles :
// Vérifier si un nombre est pair
int nombre = 42;
boolean estPair = (nombre % 2 == 0); // true
// Vérifier si divisible par 5
boolean divisiblePar5 = (nombre % 5 == 0); // false
Opérateurs d'affectation en Java
Les opérateurs d'affectation permettent d'assigner une valeur à une variable.
L'opérateur d'affectation de base est =, mais Java propose aussi des opérateurs
d'affectation composés qui combinent une opération arithmétique avec l'affectation.
Opérateur Description Exemple Équivalent
= Affectation simple x=5
+= Addition et affectation x += 3 x=x+3
-= Soustraction et affectation x -= 3 x=x-3
*= Multiplication et affectation x *= 3 x=x*3
/= Division et affectation x /= 3 x=x/3
%= Modulo et affectation x %= 3 x=x%3
public class OperateursAffectation {
public static void main(String[] args) {
int score = 100;
// Affectation simple
score = 50;
[Link]("Score: " + score); // 50
// Affectations composées
score += 10; // score = score + 10 → 60
[Link]("Après +=: " + score);
score -= 5; // score = score - 5 → 55
[Link]("Après -=: " + score);
score *= 2; // score = score * 2 → 110
[Link]("Après *=: " + score);
score /= 5; // score = score / 5 → 22
[Link]("Après /=: " + score);
score %= 7; // score = score % 7 → 1
[Link]("Après %=: " + score);
}
}
Opérateurs de comparaison en Java
Les opérateurs de comparaison (comparison operators) permettent de comparer deux
valeurs. Ils retournent toujours un résultat booléen (true ou false) et sont essentiels pour
les structures de contrôle comme if, while et for.
Opérateur Description Exemple Résultat
== Égal à 5 == 5 true
!= Différent de 5 != 3 true
> Supérieur à 5>3 true
< Inférieur à 5<3 false
>= Supérieur ou égal 5 >= 5 true
<= Inférieur ou égal 5 <= 3 false
public class OperateursComparaison {
public static void main(String[] args) {
int age = 18;
int ageMinimum = 18;
// Comparaisons numériques
boolean estMajeur = age >= ageMinimum; // true
boolean estMineur = age < ageMinimum; // false
boolean estEgal = age == ageMinimum; // true
boolean estDifferent = age != ageMinimum; // false
[Link]("Est majeur: " + estMajeur);
[Link]("Est égal: " + estEgal);
// Utilisation dans des conditions
if (age >= 18) {
[Link]("Accès autorisé");
} else {
[Link]("Accès refusé");
}
// Comparaisons multiples
int note = 85;
if (note >= 90) {
[Link]("Excellent");
} else if (note >= 70) {
[Link]("Bien");
} else if (note >= 50) {
[Link]("Passable");
} else {
[Link]("Insuffisant");
}
}
}
Important : Pour comparer des objets comme des String, n'utilisez pas == mais la
méthode equals(). L'opérateur == compare les références, pas le contenu des objets.
// Comparaison de String
String nom1 = "Java";
String nom2 = "Java";
String nom3 = new String("Java");
// INCORRECT - compare les références
boolean ref = (nom1 == nom3); // false
// CORRECT - compare le contenu
boolean contenu = [Link](nom3); // true
[Link]("Références: " + ref);
[Link]("Contenu: " + contenu);
Opérateurs logiques en Java
Les opérateurs logiques permettent de combiner plusieurs conditions booléennes. Ils
sont indispensables pour créer des expressions conditionnelles complexes dans vos
programmes Java.
Opérateur Description Exemple Résultat
&& ET logique (AND) true && false false
|| OU logique (OR) true || false true
! NON logique (NOT) !true false
Opérateur AND (&&)
L'opérateur && retourne true uniquement si les deux conditions sont vraies. Il utilise
l'évaluation en court-circuit (short-circuit) : si la première condition est fausse, la
seconde n'est pas évaluée.
int age = 25;
boolean permis = true;
// Les deux conditions doivent être vraies
boolean peutConduire = (age >= 18) && permis; // true
// Court-circuit : si age < 18, permis n'est pas vérifié
boolean mineur = (age < 18) && permis; // false (age >= 18 est false)
Opérateur OR (||)
L'opérateur || retourne true si au moins une des conditions est vraie. Il utilise aussi
l'évaluation en court-circuit : si la première condition est vraie, la seconde n'est pas
évaluée.
boolean estWeekend = true;
boolean estVacances = false;
// Au moins une condition doit être vraie
boolean peutSeReposer = estWeekend || estVacances; // true
// Court-circuit
boolean repos = true || verificationCouteuse(); // true (méthode non appelée)
Opérateur NOT (!)
L'opérateur ! inverse une valeur booléenne : true devient false et vice-versa.
boolean estConnecte = false;
boolean estDeconnecte = !estConnecte; // true
// Utilisation dans des conditions
if (!estConnecte) {
[Link]("Veuillez vous connecter");
}
Combinaison d'opérateurs logiques
public class OperateursLogiques {
public static void main(String[] args) {
int age = 25;
boolean permis = true;
boolean assurance = true;
boolean voiture = false;
// Combiner plusieurs conditions
boolean peutLouer = (age >= 21) && permis && assurance; // true
// Conditions complexes avec parenthèses
boolean peutVoyager = (voiture || peutLouer) && assurance; // true
// Négation de conditions
boolean doitPrendreTransport = !voiture && !peutLouer; // false
if (age >= 18 && permis) {
[Link]("Peut conduire");
}
if (age < 16 || !permis) {
[Link]("Ne peut pas conduire");
}
}
}
Opérateurs d'incrémentation et décrémentation
Les opérateurs ++ (incrémentation) et -- (décrémentation) permettent d'augmenter ou
diminuer la valeur d'une variable de 1. Ils existent sous deux formes : préfixe et postfixe,
avec des comportements différents.
Opérateur Description Exemple Résultat
++x Pré-incrémentation Incrémente puis retourne x+1
x++ Post-incrémentation Retourne puis incrémente x puis x + 1
--x Pré-décrémentation Décrémente puis retourne x-1
x-- Post-décrémentation Retourne puis décrémente x puis x - 1
public class OperateursIncrementation {
public static void main(String[] args) {
int compteur = 5;
// Post-incrémentation (x++)
int a = compteur++; // a = 5, compteur = 6
[Link]("a: " + a + ", compteur: " + compteur);
// Pré-incrémentation (++x)
compteur = 5;
int b = ++compteur; // b = 6, compteur = 6
[Link]("b: " + b + ", compteur: " + compteur);
// Post-décrémentation (x--)
compteur = 5;
int c = compteur--; // c = 5, compteur = 4
[Link]("c: " + c + ", compteur: " + compteur);
// Pré-décrémentation (--x)
compteur = 5;
int d = --compteur; // d = 4, compteur = 4
[Link]("d: " + d + ", compteur: " + compteur);
// Usage classique dans les boucles
for (int i = 0; i < 10; i++) {
[Link](i + " ");
}
}
}
Opérateur ternaire en Java
L'opérateur ternaire ? : est une forme abrégée de l'instruction if-else. Il permet
d'évaluer une condition et de retourner une valeur parmi deux possibles. La syntaxe est
: condition ? valeurSiVrai : valeurSiFaux
public class OperateurTernaire {
public static void main(String[] args) {
int age = 20;
// Forme longue avec if-else
String statut1;
if (age >= 18) {
statut1 = "Majeur";
} else {
statut1 = "Mineur";
}
// Forme courte avec opérateur ternaire
String statut2 = (age >= 18) ? "Majeur" : "Mineur";
[Link](statut2); // Majeur
// Exemples d'utilisation
int nombre = -5;
String signe = (nombre >= 0) ? "positif" : "négatif";
int a = 10, b = 20;
int max = (a > b) ? a : b; // 20
// Ternaire imbriqué (à utiliser avec modération)
int score = 85;
String mention = (score >= 90) ? "Excellent" :
(score >= 70) ? "Bien" :
(score >= 50) ? "Passable" : "Insuffisant";
[Link]("Mention: " + mention); // Bien
}
}
Conclusion
Les opérateurs Java sont des outils essentiels pour manipuler les données et contrôler
le flux de vos programmes. Que ce soit pour effectuer des calculs arithmétiques avec +, -
, *, /, comparer des valeurs avec ==, <, >, ou combiner des conditions avec && et ||,
maîtriser ces opérateurs vous permettra d'écrire du code Java efficace et expressif.
N'oubliez pas d'utiliser des parenthèses pour clarifier vos expressions, de comprendre la
différence entre == et equals(), et de faire attention à la division entière. Avec de la
pratique, l'utilisation des opérateurs deviendra naturelle.
CONTINUEZ VOTRE APPRENTISSAGE