2.2.1 – Opérateurs arithmétiques

Les opérateurs arithmétiques permettent d'effectuer des calculs mathématiques de base : addition, soustraction, multiplication, division, et modulo. Ces opérateurs fonctionnent avec les types numériques (int, double, float, etc.).

➕ Les opérateurs arithmétiques de base

📝 Exemples d'utilisation

int a = 10;
int b = 3;

int somme = a + b;        // 13
int difference = a - b;   // 7
int produit = a * b;      // 30
int quotient = a / b;     // 3 (division entière)
int reste = a % b;        // 1 (reste de 10 ÷ 3)

⚠️ Division entière vs Division décimale

La division en Java dépend des types utilisés :

Division entière (avec int)

Quand vous divisez deux entiers, le résultat est un entier (la partie décimale est tronquée) :

int a = 10;
int b = 3;
int resultat = a / b;  // Résultat : 3 (pas 3.333...)

int c = 7;
int d = 2;
int quotient = c / d;  // Résultat : 3 (pas 3.5)

Division décimale (avec double ou float)

Pour obtenir un résultat décimal, utilisez des types décimaux :

double a = 10.0;
double b = 3.0;
double resultat = a / b;  // Résultat : 3.3333333333333335

// Ou avec int mais conversion
int x = 10;
int y = 3;
double resultat2 = (double) x / y;  // Résultat : 3.3333333333333335

🔢 Opérateur modulo (%)

L'opérateur modulo retourne le reste de la division entière :

int reste1 = 10 % 3;   // 1 (car 10 = 3×3 + 1)
int reste2 = 17 % 5;   // 2 (car 17 = 5×3 + 2)
int reste3 = 20 % 4;   // 0 (car 20 = 4×5 + 0)
int reste4 = 7 % 2;    // 1 (utile pour vérifier si un nombre est pair/impair)

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

Java offre des opérateurs spéciaux pour augmenter ou diminuer une variable de 1 :

Opérateurs ++ et --

int x = 5;

// Incrémentation (ajouter 1)
x++;        // x devient 6 (équivalent à x = x + 1)
++x;        // x devient 7 (équivalent à x = x + 1)

// Décrémentation (soustraire 1)
x--;        // x devient 6 (équivalent à x = x - 1)
--x;        // x devient 5 (équivalent à x = x - 1)

Préfixe vs Suffixe

Il y a une différence subtile entre ++x (préfixe) et x++ (suffixe) :

int a = 5;
int b = ++a;  // a devient 6, puis b = 6
// Résultat : a = 6, b = 6

int c = 5;
int d = c++;  // d = 5, puis c devient 6
// Résultat : c = 6, d = 5

🔀 Opérateurs d'assignation composés

Java offre des opérateurs d'assignation composés pour simplifier certaines opérations :

int x = 10;

x += 5;   // Équivalent à x = x + 5;  → x = 15
x -= 3;   // Équivalent à x = x - 3;  → x = 12
x *= 2;   // Équivalent à x = x * 2;  → x = 24
x /= 4;   // Équivalent à x = x / 4;  → x = 6
x %= 5;   // Équivalent à x = x % 5;  → x = 1

📊 Priorité des opérateurs

Les opérateurs ont une priorité d'exécution. Voici l'ordre de priorité (du plus prioritaire au moins prioritaire) :

1. Parentheses () : Toujours évaluées en premier
2. Multiplication, Division, Modulo *, /, %
3. Addition, Soustraction +, -

int resultat1 = 2 + 3 * 4;      // 14 (pas 20) : 3*4 d'abord, puis +2
int resultat2 = (2 + 3) * 4;   // 20 : parenthèses d'abord
int resultat3 = 10 / 2 + 3;    // 8 : 10/2 d'abord, puis +3
int resultat4 = 10 / (2 + 3);   // 2 : parenthèses d'abord

💡 Points clés à retenir

• Opérateurs de base : +, -, *, /, %
• Division entière : Avec int, la partie décimale est tronquée
• Division décimale : Utilisez double ou float pour obtenir des décimales
• Modulo : Retourne le reste de la division
• Incrémentation : ++x ou x++ (ajoute 1)
• Décrémentation : --x ou x-- (soustrait 1)
• Assignation composée : +=, -=, *=, /=, %=
• Priorité : Parenthèses → * / % → + -