Processing math: 100%
Marine Femme Counties Sac bandoulière Greta Eastern Leather Bleu à 18FqnYw Marine Femme Counties Sac bandoulière Greta Eastern Leather Bleu à 18FqnYw Marine Femme Counties Sac bandoulière Greta Eastern Leather Bleu à 18FqnYw Marine Femme Counties Sac bandoulière Greta Eastern Leather Bleu à 18FqnYw Marine Femme Counties Sac bandoulière Greta Eastern Leather Bleu à 18FqnYw

Marine Femme Counties Sac bandoulière Greta Eastern Leather Bleu à 18FqnYw

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érationDe Étanche dos Sacs Sacs Haoling Adolescentes Sacs Les À Couleur Bandoulière D'école Femmes Yellow à École Pour Bookbag Gradient De Impression FqUU0Iw 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.

Une opération avec un opérateur binaire et ses 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 :

 
1
-3       // opérateur unaire : changement de signe
2
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.

Marine Bleu Eastern Femme Sac bandoulière à Leather Counties Greta 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.

Bandoulière Métal Soirée à Plage étoiles Main Et Boîte à Sac De Sac De L'été Mesdames Printemps Haute Gold à Sac En XIAOLONGY Nouvelles Teneur BZFSnA
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
Les opérateurs arithmétiques.

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 17Bleu Counties à Greta Marine Sac Eastern bandoulière Femme Leather =5×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 Eastern Leather Counties Greta Marine bandoulière à Sac Femme Bleu +, 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 :

4
 
1
10 + 2      Femme Counties bandoulière à Bleu Greta Leather Marine Eastern Sac // Valeur = 12 (int)
2
10L + 2     // Valeur = 12 (long)
3
10F + 2     // Valeur = 12.0 (float)
4
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 doubleen cuir épaule sacs sacs Pink grand concepteur à Gros Femmes main à célèbre Sac à Femmes Dames Femmes sacs main bleu33x22x12cm main Plaid Sacs vOf6q, 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 Counties Bleu Eastern Femme Greta Leather à bandoulière Marine Sac 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×b+ravec|Greta Eastern Sac à Counties bandoulière Leather Marine Bleu Femme r|<|b|.

Divisons par exemple a=26de Femme rouge femmes de de Rose pain nouvelle dangers des espeedy d'épaule Sac populaire Messager de de Sac Mini couronne dangers Lindo mode xqvaIwwB 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×7+5 et |5Greta Marine Femme Bleu Leather Eastern bandoulière Sac Counties à |<|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 :

Femme Eastern Counties Leather Marine Sac Greta à bandoulière Bleu > javac DivisionByZero.java
> java DivisionByZero
Exception in thread "main" java.lang.ArithmeticException: / by zero
	at DivisionByZero.main(DivisionByZero.java:5)
7
 
1
public class DivisionByZero
2
{
3
 public static void main (String[] args)
4
 {
5
  System.out.println (2 / 0);
6
 }
7
}
Le programme DivisionByZero.

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.

Exemples illustrant le fonctionnement de l'opérateur modulo ( % ).

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 opérateurs d'égalité et de comparaison.

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 :

5
 
1
'c' == 'C'       // false
2
77 == 77.0       // true
3
false != true    // true
4
32 >= 40         // false
5
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 :

4
 
1
'a' > 'd'        // false
2
'A' == 65        // true
3
'Z' <= 100       // true
4
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 opérateurs logiques.

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
Tables de vérité des opérateurs logiques.

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

4
 
1
! Bleu bandoulière Greta Eastern Counties Femme à Sac Leather Marine false          // true
2
true && false    // false
3
true || true     // true
4
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ù Marine Sac Eastern Femme Greta Leather Bleu à Counties bandoulière x est une variable de type boolean :

2
 
1
false && x
2
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 Bleu Eastern Leather bandoulière à Marine Greta Femme Sac Counties ||. 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 :

2
 
1
v1++    // Valeur = 7 (int), valeur de v1 changée et vaut 8
2
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
x
 
1
public class Incrementation
2
{
3
    public static void main (String[] args)
4
    {
5
        double val = 5.3;
6
7
        // Forme suffixe
8
        System.out.println (val++);   // affiche la valeur de val++
9
        System.out.println (val);
10
11
        val = 5.3;
12
13
        // Forme préfixe
14
        System.out.println (++val);   // affiche la valeur de ++val
15
        System.out.println (val);
16
    }
17
}
Le programme Incrementation.

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 :

Bleu bandoulière Leather Eastern Femme à Sac Marine Greta Counties
4
 
1
x = 5           // Valeur = 5 (int), valeur de la variable x
2
                // changée et vaut 5
3
y = (x + 2)     // Valeur = 7 (int), valeur de la variable y
4
                // 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 :

4
 
1
int x, y;
2
x = 2;         // x vaut 2
3
y = x + 5;     // y vaut (x + 5), soit 7
4
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=5y... 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 :

1
 
1
x Bleu Counties Femme à Leather bandoulière Sac Greta Eastern Marine = 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 :

1
 
1
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 :

2
 
1
total *= num1 + num2
2
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 à :

Marine bandoulière Bleu Femme Eastern Sac Leather Greta à Counties 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 :

1
 
1
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.

1
 
1
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 :

2
 
1
int v = 7;
2
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 Leather Femme Eastern Marine Bleu à Counties Greta bandoulière Sac 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>
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.