Opérateurs Arithmétiques Binaires en Java

Dans le langage Java, nous utilisons fréquemment des opérateurs qui prennent deux opérandes, appelés opérateurs binaires. Ces opérateurs sont les plus couramment utilisés dans le langage Java. Ils permettent d’effectuer des opérations mathématiques sur des variables, de créer des expressions logiques et d’effectuer des assignations de variables basiques.

Les opérateurs binaires sont souvent combinés dans des expressions complexes avec d’autres opérateurs binaires. Par conséquent, la priorité des opérateurs est cruciale pour évaluer correctement ces expressions. Dans cette section, nous commencerons par les opérateurs arithmétiques binaires, avant d’explorer d’autres types d’opérateurs binaires.

Les Opérateurs Arithmétiques en Java

Les opérateurs arithmétiques sont ceux qui opèrent sur des valeurs numériques. Voici un aperçu complet de ces opérateurs :

Opérateur	Exemple	Description
Addition	a + b	Additionne deux valeurs numériques
Soustraction	c – d	Soustrait deux valeurs numériques
Multiplication	e * f	Multiplie deux valeurs numériques
Division	g / h	Divise une valeur numérique par une autre
Modulo	i % j	Retourne le reste de la division d’une valeur numérique par une autre

Vous connaissez probablement tous ces opérateurs sauf le modulo grâce aux mathématiques élémentaires. Si vous ne savez pas ce qu’est le modulo, ne vous inquiétez pas, nous allons l’aborder prochainement.

Les opérateurs arithmétiques incluent également les opérateurs unaires, ++ et –, que nous avons déjà couverts. Notez que les opérateurs multiplicatifs (*, /, %) ont une priorité plus élevée que les opérateurs additifs (+, -). Examinons l’expression suivante :

int prix = 2 * 5 + 3 * 4 - 8;

Tout d’abord, vous évaluez 2 * 5 et 3 * 4, ce qui réduit l’expression à :

int prix = 10 + 12 - 8;

Ensuite, vous évaluez les termes restants de gauche à droite, ce qui donne une valeur de prix de 14.

Note Importante sur l’Utilisation des Opérateurs

Tous les opérateurs arithmétiques peuvent être appliqués à n’importe quel type primitif Java, à l’exception de boolean. De plus, seuls les opérateurs + et += peuvent être appliqués aux valeurs String, ce qui résulte en une concaténation de chaînes.

Utilisation des Parenthèses

La priorité des opérateurs peut être modifiée explicitement en entourant de parenthèses les sections que vous souhaitez évaluer en premier.

Modifier l’Ordre des Opérations

Reprenons l’exemple du prix précédent. Le fragment de code suivant contient les mêmes valeurs et opérateurs, dans le même ordre, mais avec deux paires de parenthèses ajoutées :

int prix = 2 * ((5 + 3) * 4 - 8);

Cette fois, vous évaluez d’abord l’opérateur d’addition 5 + 3, ce qui réduit l’expression à :

int prix = 2 * (8 * 4 - 8);

Vous pouvez encore réduire cette expression en multipliant les deux premières valeurs entre parenthèses :

int prix = 2 * (32 - 8);

Ensuite, vous soustrayez les valeurs entre parenthèses avant d’appliquer les termes en dehors des parenthèses :

int prix = 2 * 24;

Enfin, vous multipliez le résultat par 2, ce qui donne une valeur de 48 pour prix.

Astuce Pratique

Lorsque vous rencontrez du code dans votre carrière professionnelle où vous n’êtes pas sûr de l’ordre des opérations, n’hésitez pas à ajouter des parenthèses optionnelles. Bien que souvent non requises, elles peuvent améliorer la lisibilité du code.

Vérification de la Syntaxe des Parenthèses

Lorsque vous travaillez avec des parenthèses, vous devez vous assurer qu’elles sont toujours valides et équilibrées. Considérez les exemples suivants :

long pigeon = 1 + ((3 * 5) / 3; // NE COMPILE PAS
int merle = (9 + 2) + 3) / (2 * 4; // NE COMPILE PAS

Le premier exemple ne compile pas car les parenthèses ne sont pas équilibrées. Il y a une parenthèse ouvrante sans parenthèse fermante correspondante. Le second exemple a un nombre égal de parenthèses ouvrantes et fermantes, mais elles ne sont pas équilibrées correctement.

Essayons un autre exemple :

short rougeGorge = 3 + [(4 * 2) + 4]; // NE COMPILE PAS

Cet exemple ne compile pas car Java, contrairement à certains autres langages de programmation, ne permet pas d’utiliser des crochets [] à la place des parenthèses. Si vous remplacez les crochets par des parenthèses, l’exemple compilera correctement.

Les Opérateurs de Division et Modulo

Plongeons dans le fonctionnement de l’opérateur modulo (%). Cet opérateur, parfois appelé opérateur de reste, calcule simplement le reste d’une division entre deux nombres. Prenons un exemple concret : quand vous divisez 9 par 3, la division est exacte sans reste, donc 9 % 3 donne 0. En revanche, quand vous divisez 11 par 3, il y a un reste, donc 11 % 3 donne 2.

Voici quelques exemples pour illustrer cette différence :

System.out.println(9 / 3); // Affiche 3
System.out.println(9 % 3); // Affiche 0

System.out.println(10 / 3); // Affiche 3
System.out.println(10 % 3); // Affiche 1

System.out.println(11 / 3); // Affiche 3
System.out.println(11 % 3); // Affiche 2

System.out.println(12 / 3); // Affiche 4
System.out.println(12 % 3); // Affiche 0

Remarquez que les résultats de la division n’augmentent que lorsque la valeur de gauche passe de 11 à 12. En revanche, la valeur du reste (modulo) augmente de 1 à chaque fois que la valeur de gauche augmente, jusqu’à ce qu’elle revienne à zéro. Pour un diviseur y donné, l’opération modulo donne toujours une valeur entre 0 et (y – 1) pour les dividendes positifs.

Comprendre la Différence entre Division et Modulo

Pour les valeurs entières, la division donne la partie entière du résultat (le plancher), tandis que le modulo donne le reste. Si vous entendez parler de “valeur plancher”, c’est simplement la valeur sans la partie décimale. Par exemple, la valeur plancher est 4 pour chacune des valeurs 4.0, 4.5 et 4.9999999.

La Promotion Numérique en Java

Maintenant que vous maîtrisez les opérateurs arithmétiques, il est essentiel de comprendre la promotion numérique. Java peut parfois se comporter de manière surprenante lors de ces opérations.

Les Règles de Promotion Numérique

Voici les règles essentielles que Java suit lors de l’application des opérateurs :

1. Si deux valeurs ont des types de données différents, Java va automatiquement promouvoir l’une des valeurs vers le plus grand des deux types.
2. Si l’une des valeurs est de type intégral et l’autre de type flottant, Java va automatiquement promouvoir la valeur intégrale vers le type flottant.
3. Les types de données plus petits (byte, short et char) sont d’abord promus en int lorsqu’ils sont utilisés avec un opérateur arithmétique binaire Java.
4. Après toutes les promotions, la valeur résultante aura le même type de données que ses opérandes promus.

Exemples Pratiques de Promotion

Analysons quelques exemples concrets :

Exemple 1 : Promotion int vers long

int nombre = 1;
long grand = 33;
var resultat = nombre * grand;

Dans ce cas, nombre est automatiquement promu en long avant la multiplication, car grand est de type long. Le résultat sera donc de type long.

Exemple 2 : Promotion vers double

double x = 39.21;
float y = 2.1f; // Notez le 'f' pour indiquer un float
var resultat = x + y;

Ici, y est automatiquement promu en double avant l’addition, car x est de type double. Le résultat sera de type double.

Exemple 3 : Promotion de short vers int

short petit = 10;
short nombre = 3;
var resultat = petit * nombre;

Dans ce cas, petit et nombre sont tous deux promus en int avant la multiplication, donnant un résultat de type int. Si vous essayez d’assigner ce résultat à une variable short sans cast, le code ne compilera pas.

Exemple 4 : Promotions Multiples

short valeur = 14;
float decimal = 13;
double grand = 30;
var resultat = valeur * decimal / grand;

Dans cet exemple :

1. valeur est d’abord promu en int car c’est un short utilisé dans une opération binaire
2. Cet int est ensuite promu en float pour la multiplication avec decimal
3. Le résultat float est finalement promu en double pour la division par grand
4. Le résultat final est donc de type double

Conseil Pratique

Lorsque vous travaillez avec les opérateurs arithmétiques en Java, gardez toujours à l’esprit le type de vos variables, des valeurs intermédiaires et des résultats. Appliquez les règles de priorité des opérateurs et les parenthèses, tout en prenant en compte les promotions de types qui se produisent au fil des calculs.