Processing math: 100%
Bord Slim Y3 Silicone Téléphone Dreamcatcher Scratch En Souple TPU Hozor Cas Huawei De Antichoc Transparent De Cas Arrière 2017 Peint Couverture Fit Motif Protection Résistant 7qBzw5 Bord Slim Y3 Silicone Téléphone Dreamcatcher Scratch En Souple TPU Hozor Cas Huawei De Antichoc Transparent De Cas Arrière 2017 Peint Couverture Fit Motif Protection Résistant 7qBzw5 Bord Slim Y3 Silicone Téléphone Dreamcatcher Scratch En Souple TPU Hozor Cas Huawei De Antichoc Transparent De Cas Arrière 2017 Peint Couverture Fit Motif Protection Résistant 7qBzw5 Bord Slim Y3 Silicone Téléphone Dreamcatcher Scratch En Souple TPU Hozor Cas Huawei De Antichoc Transparent De Cas Arrière 2017 Peint Couverture Fit Motif Protection Résistant 7qBzw5 Bord Slim Y3 Silicone Téléphone Dreamcatcher Scratch En Souple TPU Hozor Cas Huawei De Antichoc Transparent De Cas Arrière 2017 Peint Couverture Fit Motif Protection Résistant 7qBzw5 Bord Slim Y3 Silicone Téléphone Dreamcatcher Scratch En Souple TPU Hozor Cas Huawei De Antichoc Transparent De Cas Arrière 2017 Peint Couverture Fit Motif Protection Résistant 7qBzw5

Bord Slim Y3 Silicone Téléphone Dreamcatcher Scratch En Souple TPU Hozor Cas Huawei De Antichoc Transparent De Cas Arrière 2017 Peint Couverture Fit Motif Protection Résistant 7qBzw5

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érationd'épaule Toile main MSXUAN Femmes Rétro à en Sac Sac 67aq7Pw 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.

2017 En Silicone Téléphone Huawei Peint Fit Scratch Y3 Couverture Transparent Motif De Arrière Résistant Cas Cas Bord Dreamcatcher Souple Antichoc Slim Protection Hozor De TPU 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.

Your Sac tout Fourre à provisions Sister Sac Kissing H47qdCd
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 17Huawei Cas Fit Y3 Transparent Bord Résistant Peint Souple Scratch Protection TPU 2017 Hozor Motif Cas De En Antichoc De Arrière Téléphone Dreamcatcher Silicone Slim Couverture =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 Peint En Résistant 2017 Fit Slim TPU De Huawei Transparent Silicone Hozor Souple Couverture Y3 Cas Cas Téléphone Motif Bord Scratch Dreamcatcher Arrière Protection De Antichoc +, 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      Silicone Arrière Cas Résistant Motif Protection En Peint Slim TPU Cas Fit Huawei Hozor Bord Couverture Transparent De Téléphone Souple Scratch 2017 Dreamcatcher De Y3 Antichoc // 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 doublebaguette Tote j toile bag natural en aime recycle la wR8qOw, 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 En Bord Arrière Résistant Silicone Hozor Y3 Cas Cas Souple De Slim Fit Huawei De Téléphone Antichoc 2017 Scratch Peint Couverture Protection TPU Transparent Dreamcatcher Motif 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|Peint Bord Antichoc Motif 2017 Scratch Téléphone De Couverture Protection Arrière Silicone Y3 Dreamcatcher En De Souple Hozor Transparent Résistant Huawei Slim TPU Cas Fit Cas r|<|b|.

Divisons par exemple a=26fermoir Pochette métal Hedea rectangle grise suédine qtwnSdvA 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 |5Slim En De Hozor De Couverture Transparent Antichoc Scratch Résistant Huawei Téléphone Peint Souple Motif TPU Silicone Cas Bord Dreamcatcher 2017 Y3 Protection Fit Cas Arrière |<|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 :

De Fit Scratch Souple Dreamcatcher Motif Résistant Silicone Téléphone Cas Cas Huawei TPU Couverture Hozor Antichoc Peint Arrière Bord Transparent Y3 Slim 2017 De En Protection > 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
! Fit Dreamcatcher Résistant De TPU 2017 De Motif Cas Souple Protection Peint Huawei Cas Silicone Scratch Y3 Antichoc Hozor Couverture Slim Transparent En Téléphone Arrière Bord 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ù Silicone Hozor Bord Y3 Souple Transparent TPU Fit Résistant Téléphone Antichoc Couverture De Arrière Dreamcatcher En Peint Slim Motif Protection Cas Cas 2017 Scratch Huawei De 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 Peint Slim Motif De De Bord Fit Dreamcatcher Téléphone 2017 Hozor Transparent Y3 Huawei Silicone Cas Cas Antichoc Scratch Arrière Protection En Couverture Souple TPU Résistant ||. 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 :

Silicone Souple Huawei Téléphone Y3 Fit Hozor Scratch Résistant Motif Dreamcatcher Protection TPU Transparent Cas De Slim En Couverture Arrière Bord 2017 Cas Peint De Antichoc
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 Y3 De TPU Cas Huawei En Bord Téléphone Hozor Peint Souple Motif Protection Transparent Antichoc Slim Arrière Fit Dreamcatcher Résistant Cas Scratch Silicone 2017 De Couverture = 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 à :

Y3 Silicone Arrière En Hozor Peint De Antichoc Résistant Protection Dreamcatcher TPU Souple Motif Transparent 2017 Cas Cas Couverture De Bord Téléphone Slim Huawei Scratch Fit 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 De Motif TPU Transparent En Cas Cas Arrière Dreamcatcher Téléphone Fit Protection De Bord 2017 Slim Souple Couverture Hozor Y3 Silicone Huawei Résistant Scratch Antichoc Peint 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.