UKOnline

Opérateur

Un programme manipule des données, qu'elles soient stockées dans une variable ou un constante, ou que ce soit des littéraux. On veut également pouvoir effectuer des opérations sur ces données, comme par exemple des additions, des multiplications, etc.

Pour réaliser des opérations, on va utiliser des opérateurs. Ceux-ci permettent d'effectuer une opération bien définie sur des valeurs appelées opérandes, en produisant un résultat appelé valeur de l'opération. Cette valeur possède un type également bien définit par l'opération. La figure 1 montre un opérateur qui nécessite deux opérandes.

Il y a de nombreux opérateurs en Java qu'on peut classer de différentes manières. On peut les classer en fonction du nombre d'opérandes qu'ils requièrent, ce qui donne trois catégories :

• les opérateurs unaires requièrent un unique opérande ;
• les opérateurs binaires en requièrent deux ;
• et enfin les opérateurs ternaires en nécessitent trois.

Voici deux exemples d'opérations qui utilisent un opérateur :

-3 // opérateur unaire : changement de signe 7 + 2 // opérateur binaire : addition

Le premier exemple montre un opérateur unaire (changement de signe) qui agit sur un opérande qui est le littéral 3. Le second montre un opérateur binaire (addition) qui agit sur deux opérandes qui sont les littéraux 7 et 2.

On peut également classer les opérateurs selon la nature des opérations qu'ils effectuent. C'est le classement qui a été choisi pour organiser cette section. Pour chaque opérateur, on va s'intéresser à plusieurs caractéristiques :

• la description de l'opération effectuée ;
• les types des opérandes sur lesquels il est applicable ;
• et le type du résultat qu'il calcule.

Opérateur arithmétique

Les opérateurs arithmétiques de Java sont repris sur la figure 2 avec un exemple où x et y représentent des opérandes. Les quatre premiers opérateurs vous sont normalement familiers. Le cinquième permet de calculer le reste de la division entière, l'avant-dernier permet de changer le signe de son opérande et enfin, le dernier ne fait rien.

	Opérateur	Description	Exemple
binaire	+	addition	x + y
	-	soustraction	x - y
	*	multiplication	x * y
	/	division	x / y
	%	modulo	x % y
unaire	-	changement de signe	-x
	+	signe plus	+x

L'opérateur modulo calcule donc le reste de la division entière. Par exemple, 17 % 3 a pour valeur 2 car si on divise 17 par 3, on obtient 5 comme quotient, avec un reste de 2. En effet, on peut écrire que $17 = 5 \times 3 + 2$. Cet opérateur est décrit plus en détails plus loin dans cette section.

L'opérateur unaire - calcule l'opposé de son opérande ; on l'utilise notamment pour écrire des nombres négatifs. L'opérateur unaire +, quant à lui, se contente de renvoyer la valeur de son opérande. On ne l'utilise pour ainsi dire jamais.

Les opérandes de tous les opérateurs arithmétiques doivent être de type numérique, c'est-à-dire des nombres entiers ou flottants. Chaque opérateur existe en quatre versions; la différence étant le type de la valeur calculée. Voici quelques exemples d'opérations avec le résultat calculé et le type correspondant :

10 + 2 // Valeur = 12 (int) 10L + 2 // Valeur = 12 (long) 10F + 2 // Valeur = 12.0 (float) 10 + 2.0 // Valeur = 12.0 (double)

Rappelez-vous que le L ajouté derrière un littéral fait en sorte qu'il soit considéré comme une donnée de type long et que le F permet d'en faire un float. Vous voyez bien grâce à cet exemple que l'opérateur d'addition produit à chaque fois le même résultat (le nombre 12), mais avec un type différent.

Pour connaitre le type du résultat d'une opération arithmétique, il suffit d'appliquer les règles suivantes dans l'ordre :

1. si l'un des opérandes est de type double, le résultat est de type double ;
2. si l'un des opérandes est de type float, le résultat est de type float ;
3. si l'un des opérandes est de type long, le résultat est de type long ;
4. et dans tous les autres cas, le résultat est de type int.

La même règle s'applique aux deux opérateurs unaires. Tous les opérateurs arithmétiques existent donc en quatre versions différentes, le type du résultat dépendant uniquement des types des opérandes.

Division entière et reste

Lorsqu'on utilise l'opérateur de division ( / ) avec des opérandes de type entiers, le résultat est un entier de type long ou int ; il s'agit donc d'une division entière. Par exemple, la valeur de 1 / 2 est 0 et pas 0.5. Ce type de division va en fait simplement garder la partie entière du résultat, sans faire d'arrondi. Ainsi, la valeur de 3 / 4 est 0, et pas 1 qui correspondrait à l'arrondi de $^3/_4 = 0,\!75$.

L'opérateur modulo ( % ) appliqué à deux entiers calcule le reste de la division entière. Soient deux entiers $a$ et $b$; si $q$ désigne le quotient (résultat de la division entière) et $r$ le reste de la division entière, alors la relation suivante est toujours satisfaite :

$$a = q \times b + r \qquad\qquad \textrm{avec} \; |r| < |b|.$$

Divisons par exemple $a = 26$ par $b = 7$. Le quotient vaut $q = 3$ et le reste vaut $r = 5$. La relation est bien vérifiée : en effet, $26 = 3 \times 7 + 5$ et $|5| < |7|$.

L'opérateur de division et le modulo génèrent tous les deux une erreur d'exécution de type ArithmeticException: / by zero lorsqu'ils sont appliqués à deux entiers et que l'opérande de droite vaut 0. L'exemple de la figure 3 tente d'afficher le résultat de la division entière de 2 par zéro, ce qui produit l'erreur suivante lors de l'exécution :

> javac DivisionByZero.java
> java DivisionByZero
Exception in thread "main" java.lang.ArithmeticException: / by zero
	at DivisionByZero.main(DivisionByZero.java:5)

public class DivisionByZero { public static void main (String[] args) { System.out.println (2 / 0); } }

On peut comprendre comment fonctionne l'opérateur modulo si on décompose le calcul qu'il effectue en plusieurs étapes. On part de l'opérande de gauche, ensuite on lui ajoute ou soustrait l'opérande de droite successivement de sorte à faire tendre la valeur vers zéro. On continue jusqu'à ce que le résultat soit plus petit, en valeur absolue, à la valeur absolue de l'opérande de droite. La figure 4 illustre comment l'opérateur modulo calcule son résultat pour diverses situations. Remarquez qu'on peut également utiliser cet opérateur avec des nombres flottants.

Opérateur d'égalité et de comparaison

Java propose plusieurs opérateurs d'égalité et de comparaison, tous binaires, qui renvoient comme résultat un booléen (true ou false). Ceux-ci sont repris sur la figure 5. Comme on le verra dans le chapitre suivant, on les utilise notamment pour prendre des décisions dans un programme.

	Opérateur	Description	Exemple
égalité	==	égal	x == y
	!=	différent de	x != y
comparaison	<	plus petit que	x < y
	<=	plus petit ou égal à	x <= y
	>	plus grand que	x > y
	>=	plus grand ou égal à	x >= y

Les deux premiers opérateurs sont les opérateurs d'égalité ( == et != ). Ils permettent de tester si les leurs deux opérandes sont égaux ou différents. On peut les utiliser pour comparer des nombres entiers ou flottants, des caractères ou des booléens.

Les quatre derniers sont les opérateurs de comparaison qui permettent de savoir si un opérande est plus grand ou plus petit qu'un autre. Ils ne sont utilisables qu'avec des nombres entiers ou flottants et des caractères.

Voyons quelques exemples qui utilisent ces opérateurs, avec le résultat correspondant qui est toujours de type booléen :

'c' == 'C' // false 77 == 77.0 // true false != true // true 32 >= 40 // false 72.2 < 73 // true

La valeur du premier exemple est false puisque la lettre c (minuscule) n'est pas égale à la lettre C (majuscule). Il est possible de faire des comparaisons de caractères sans tenir compte de la casse comme on verra au chapitre 4. La valeur du second exemple est true puisque les deux valeurs sont égales, même si elles ne sont pas du même type (int et double). La valeur des autres exemples est facile à comprendre.

Il est également possible de comparer des caractères entre eux et avec des nombres. En effet, on a vu au chapitre précédent que les caractères sont tous associés à un nombre selon la table d'encodage utilisée (voir figure 6 en section 1.2). Voici à nouveau quelques exemples :

'a' > 'd' // false 'A' == 65 // true 'Z' <= 100 // true 12.5 >= '?' // false

Opérateur logique

Les opérateurs logiques s'appliquent sur des opérandes booléens et produisent un résultat qui est également booléen. Java comporte trois opérateurs logiques, dont un unaire et deux binaires. Ces opérateurs sont repris sur la figure 6.

	Opérateur	Description	Exemple	Résultat
unaire	!	NON logique	! x	true si x vaut false false si x vaut true
binaire	&&	ET logique	x && y	true si x et y valent true false sinon
	||	OU logique (inclusif)	x || y	true si x ou y valent true false sinon
	^	OU logique (exclusif)	x || y	true si x et y sont égaux false sinon

Les résultats calculés par ces opérateurs peuvent être représentés sous forme de tables de vérité. La figure 7 présente les tables de vérité des quatre opérateurs logiques. Le NON logique ( ! ) est un opérateur unaire qui inverse la valeur de son opérande. Le résultat calculé vaut false lorsque la valeur de son opérande est true et inversement. Le résultat du ET logique ( && ) vaut true lorsque les deux opérandes valent true et vaut false dans les autres cas.

Enfin, il y a deux versions du OU logique. Il y a tout d'abord le OU logique inclusif ( || ) qui produit true comme résultat lorsqu'au moins un des opérandes vaut true et false sinon. Le OU logique exclusif ( ^ ), quant à lui, ne produit true comme résultat que lorsqu'un et un seul des deux opérandes vaut true.

x	y	! x	x && y	x || y	x ^ y
false	false	true	false	false	false
false	true		false	true	true
true	false	false	false	true	true
true	true		true	true	false

Voici quelques exemples utilisant ces opérateurs, accompagnés du résultat de l'opération qui est toujours de type boolean :

! false // true true && false // false true || true // true true ^ true // false

Propriété de court-circuit

Une caractéristique importante des opérateurs && et || est qu'ils peuvent être court-circuités. Cela signifie que les deux opérandes ne seront pas systématiquement évalués.

Il y a en effet des situations dans lesquelles le résultat de l'opération peut être déterminé rien qu'en connaissant la valeur de l'opérande de gauche. Voyons le fonctionnement de cette propriété avec les deux exemples suivants où x est une variable de type boolean :

false && x true || x

La valeur du premier exemple est false. En effet, si on consulte la table de vérité du ET logique, on se rend compte qu'à partir du moment où l'un des opérandes vaut false, le résultat est toujours false. Un raisonnement similaire s'applique pour le second exemple. En effet, en consultant la table de vérité du OU logique, on voit que lorsqu'un des deux opérandes vaut true, le résultat est toujours true.

Cette propriété ne s'applique qu'aux opérateurs & et ||. L'opérateur de gauche est d'abord examiné; celui de droite est ensuite examiné, seulement si c'est nécessaire. On verra plus tard dans ce chapitre que cette propriété peut s'avérer pratique dans certaines situations.

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

L'opération d'incrémentation ( ++ ) est un opérateur unaire qui ne peut être appliqué qu'à des variables. Le résultat calculé par l'opérateur est égal à la valeur de la variable sur laquelle il est appliqué; il en est de même pour le type du résultat. On peut dès lors se demander quel est son intérêt.

Cet opérateur produit en fait un effet de bord, c'est-à-dire qu'en plus d'effectuer une opération, il va modifier la valeur de la variable sur laquelle il est appliqué, en lui ajoutant 1. De ce fait, il ne peut s'appliquer qu'à des variables contenant des nombres (entiers ou flottants).

Il y a également un opérateur de décrémentation ( -- ) qui fonctionne comme l'opérateur d'incrémentation, sauf que son effet de bord consiste à retirer 1 de la variable sur laquelle il est appliqué.

Soient les variables v1 et v2 de type int valant toutes les deux 7. L'exemple suivant montre comment utiliser ces deux opérateurs :

v1++ // Valeur = 7 (int), valeur de v1 changée et vaut 8 v2-- // Valeur = 7 (int), valeur de v2 changée et vaut 6

Il faut faire très attention lorsqu'on utilise ces opérateurs à cause de leurs effets de bord. On reviendra sur cette problématique plus tard dans ce chapitre. N'oubliez pas que ces opérateurs ne peuvent s'appliquer qu'à une variable, et on ne peut donc pas écrire 3++ ou (2 * x)++, par exemple. Par contre, comme on verra plus loin, on peut également appliquer ces opérateurs sur des variables de type char.

Forme suffixe et préfixe

Les deux opérateurs existent sous deux formes. Dans tous les exemples qu'on a vu jusqu'à présent, on a utilisé la forme suffixe de l'opérateur; celui-ci étant placé après la variable. Les deux opérateurs existent également en forme préfixe, c'est-à-dire qu'on les place avant la variable.

La différence entre les deux formes concerne le moment où l'effet de bord est appliqué. Avec la forme préfixe, il est appliqué avant que l'opérateur ait fait son opération. Pour la forme suffixe, l'opération est effectuée et l'effet de bord est ensuite appliqué. Voyons tout de suite une illustration de cette différence avec l'exemple de la figure 8 qui affiche ce qui suit à l'écran lors de son exécution :

5.3
6.3
6.3
6.3

public class Incrementation { public static void main (String[] args) { double val = 5.3; // Forme suffixe System.out.println (val++); // affiche la valeur de val++ System.out.println (val); val = 5.3; // Forme préfixe System.out.println (++val); // affiche la valeur de ++val System.out.println (val); } }

Dans le premier cas, la valeur de val++ est donc égale à la valeur de la variable (5.3). La valeur de la variable val sera ensuite incrémentée de 1. La première instruction System.out.println (val); affiche donc 6.3 à l'écran. En ce qui concerne la forme préfixe, la valeur de la variable est d'abord incrémentée de 1; la valeur de ++val est donc 6.3. Dans les deux cas, la valeur de la variable est bel et bien incrémentée.

Opérateur d'affectation

On a déjà utilisé l'opérateur d'affectation ( = ) pour initialiser une variable ou modifier sa valeur. Il s'agit en fait d'un effet de bord de l'opérateur.

L'opérateur d'affectation est binaire. L'opérande de gauche doit être une variable et l'effet de bord de l'opérateur consiste à changer sa valeur avec celle de l'opérande de droite. Le résultat de l'opération est simplement la valeur de l'opérande de droite, qui détermine également le type du résultat. Voyons deux exemples utilisant cet opérateur :

x = 5 // Valeur = 5 (int), valeur de la variable x // changée et vaut 5 y = (x + 2) // Valeur = 7 (int), valeur de la variable y // changée et vaut 7

L'opérateur d'affectation n'a pas du tout la même signification que l'égal mathématique. Il permet d'affecter une valeur à une variable et non pas d'établir une égalité entre deux entités. Voyons cela grâce à l'exemple suivant :

int x, y; x = 2; // x vaut 2 y = x + 5; // y vaut (x + 5), soit 7 x = 9; // x vaut 9, y est inchangé et vaut toujours 7

La première ligne déclare les variables x et y de type int. La seconde ligne a pour effet de bord d'affecter la valeur 2 à la variable x. La suivante va affecter la valeur de x + 5 à la variable y. Enfin, la dernière instruction change la valeur de x et n'aura aucune influence sur la valeur de y.

En mathématique, écrire $y = x + 5$ signifie que la valeur de $y$ vaut toujours celle de $x$ augmentée de $5$. On peut d'ailleurs également écrire $x + 5 = y$ ou $x = 5 - y$... En Java, l'opérateur = permet d'affecter une valeur à une variable. Une autre erreur qui est assez fréquente est due à la confusion entre l'opérateur = qui permet de faire une affectation et l'opérateur == qui permet de faire une comparaison. Ceci est parfois source d'erreurs logiques comme on le verra au chapitre suivant.

Affectation composée

On doit assez souvent modifier la valeur d'une variable en effectuant une modification par rapport à sa valeur actuelle. Prenons par exemple une variable x de type int. Si on souhaite modifier sa valeur en lui ajoutant deux, on peut écrire :

x = x + 2;

Étant donné qu'on doit souvent faire ce genre d'affectation, Java propose différents opérateurs d'affectation composée qui combinent un opérateur arithmétique avec l'opérateur d'affectation. On peut ainsi réécrire l'affectation précédente comme :

x += 2;

Ce genre de raccourci d'écriture est appelé sucre syntaxique. Il s'agit d'une construction dont on pourrait se passer, mais qui permet d'avoir un code plus compact. Tous ces opérateurs ( +=, -=, *=, /= et %= ) ont donc également un effet de bord.

Le second opérande des opérateurs d'affectation composé est d'abord évalué et l'affectation a lieu ensuite. Les deux opérations suivantes sont donc équivalentes :

total *= num1 + num2 total = total * (num1 + num2)

Par contre, l'opération total = total * num1 + num2 n'est pas équivalente aux deux précédentes. En effet, comme on le verra à la section 2.3 sur la priorité des opérateurs, la multiplication se fait avant l'addition et donc, l'opération correspond en fait à :

total = (total * num1) + num2

Opérateur conditionnel

L'opérateur conditionnel ( ? : ) est le seul opérateur ternaire. Il nécessite donc trois opérandes. Le premier doit être de type booléen et le résultat de l'opération dépend de sa valeur. Si la valeur du premier opérande vaut true, le résultat de l'opération correspond à la valeur du second opérande; sinon, il correspond à celle du troisième.

Voyons cela avec l'exemple suivant :

total > MAX ? total + 1 : total * 2

Dans cet exemple, si la valeur de la variable total est plus grande que celle de MAX, le résultat de l'opération correspondra à la valeur de total + 1; sinon, il sera égal à la valeur de total * 2. Comme on le verra dans le chapitre 3, on utilise souvent cet opérateur pour remplacer une simple condition if-else.

Les types des deux derniers opérandes doivent être compatibles. Par exemple, utiliser l'opération suivante va parfois générer une erreur de compilation car les types des deux opérandes ne sont pas les mêmes.

v == 12 ? false : 12;

Si on souhaite afficher la valeur de cette opération avec System.out.println, cela ne posera aucun problème. Par contre, si on souhaite stocker cette valeur dans une variable, on sera confronté à une erreur de compilation comme l'illustre l'exemple suivant :

int v = 7; int x = (v == 12 ? false : 12);

Le second opérande est de type boolean tandis que le troisième est de type int et on tente de stocker le résultat de l'opération dans la variable x de type int. Le compilateur génère dès lors une erreur de type « incompatible types ».

> javac ConditionalOperator.java
ConditionalOperator.java:6: incompatible types
found   : java.lang.Object&java.io.Serializable&java.lang.Comparable<? extends java.lang.Object&
java.io.Serializable&java.lang.Comparable<?>>
required: int
		int x = (v == 12 ? false : 12);
		                 ^
1 error

On verra la notion de types compatibles dans la section 4 qui traite des conversions de données.

• Précédent
• Suivant