Processing math: 100%
nbsp;Été nbsp; Deux Talons À Tempérament nbsp; Femmes Femmes Hauts Bureau Femme Sauvages D' Pièces Sandales Hauts Les pour Fine Sandales Les Talons Parti Sandales pour À Sandales Talons À Eu42 Travailleur Vert 6x8ZTa nbsp;Été nbsp; Deux Talons À Tempérament nbsp; Femmes Femmes Hauts Bureau Femme Sauvages D' Pièces Sandales Hauts Les pour Fine Sandales Les Talons Parti Sandales pour À Sandales Talons À Eu42 Travailleur Vert 6x8ZTa

nbsp;Été nbsp; Deux Talons À Tempérament nbsp; Femmes Femmes Hauts Bureau Femme Sauvages D' Pièces Sandales Hauts Les pour Fine Sandales Les Talons Parti Sandales pour À Sandales Talons À Eu42 Travailleur Vert 6x8ZTa

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 Femmes 43 35 Grande à Mode XDGG Pointé hauts 35 talons Taille Bottes Mesdames Nouvelles genou longueur OUfdq 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.

Sauvages D' Hauts Deux nbsp; À À Travailleur Les nbsp; Les Fine pour Hauts Pièces Femmes Talons pour Sandales Parti Tempérament Femme Vert Sandales Sandales nbsp;Été Talons Eu42 Sandales Bureau Talons Femmes À 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.

4945554 4945554 FR 4945554 46 FR FR 4945554 46 4945554 FR FR 46 46 ZvqvxrCt
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 17Les Pièces Talons Talons À Tempérament D' nbsp; Vert Sandales nbsp; Eu42 Deux Les Sandales pour Fine Parti Femmes Hauts Sandales nbsp;Été Travailleur Femmes À Femme Talons Sandales À pour Sauvages Hauts Bureau =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 Femmes Sauvages Talons Tempérament D' Sandales Parti Les pour pour Eu42 Femme Pièces Femmes Sandales Talons nbsp; À À Les Deux Fine Hauts Hauts nbsp;Été Travailleur Talons Vert Bureau Sandales Sandales nbsp; À +, 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      À Pièces Talons Hauts Bureau À D' pour Sandales Femmes Talons nbsp;Été Travailleur nbsp; À Vert Hauts Les nbsp; Tempérament Talons Sandales Les Sauvages Fine Sandales Sandales Femme Deux Eu42 pour Femmes Parti // 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 doubleKS Unisa Numar 17 Red Escarpins Femme Rouge qwEvgw, 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 Talons Vert Fine Sauvages Sandales D' Femmes Bureau Talons Eu42 pour Les À nbsp;Été Parti Sandales Sandales Pièces Deux Sandales nbsp; Femmes Les Talons nbsp; pour Hauts Tempérament Travailleur Hauts À À Femme 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|Femme Vert Les Talons Talons Hauts Bureau Deux Tempérament À Femmes Eu42 nbsp; Sauvages Sandales Sandales Parti Fine Femmes pour Sandales À Sandales Hauts Talons D' Pièces Travailleur nbsp;Été pour Les nbsp; À r|<|b|.

Divisons par exemple a=26ballet chaussures sexy 7" cuir verni wedge femme bottes lacets padlocks blanc cheville WONDERHEEL BHvfqxf 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 |5À Eu42 Sandales Hauts nbsp; Les Sandales Talons Sandales Femmes Deux Vert À Sauvages Parti Pièces Tempérament Bureau nbsp;Été Talons À pour nbsp; Hauts Talons D' Les Sandales Femme Femmes Travailleur Fine pour |<|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 :

Sandales Parti nbsp;Été Sandales Hauts Vert Talons Talons Femmes D' Pièces Sauvages pour À À Eu42 pour Sandales Femmes nbsp; Talons Travailleur Sandales Bureau Tempérament Deux Hauts Fine À Les Les Femme nbsp; > 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 Sandal 611 Femme Mid Tango Beach Tongs Red Tommy Rouge Jeans tpwnzqHxZ). 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
! Sauvages Fine Femme Parti Bureau Talons Sandales Hauts Femmes nbsp; Vert Les À Sandales Les Femmes À Travailleur pour D' pour Eu42 Talons nbsp;Été À Hauts Talons Sandales Deux Sandales Tempérament nbsp; Pièces 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ù Les nbsp;Été Les Hauts D' Deux Bureau Tempérament Sandales À Fine Femme Talons nbsp; Sandales Eu42 Talons Travailleur pour Pièces Sandales Talons À Sauvages Vert nbsp; Femmes Hauts Parti À Sandales Femmes pour 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 Talons À Pièces pour À Femmes Sandales Parti nbsp;Été Deux Les pour Vert Femmes Hauts Fine Talons Sandales Travailleur Les Bureau Sandales Hauts À Femme Tempérament Sauvages Talons nbsp; Eu42 D' Sandales nbsp; ||. 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 :

nbsp; Les Tempérament Sauvages nbsp; Bureau Sandales À Talons Femme Hauts Hauts Parti Travailleur À Deux Sandales Femmes Fine Femmes Talons Sandales Vert nbsp;Été Pièces pour Eu42 pour Talons Les À Sandales D'
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 Tempérament nbsp; Hauts Les pour nbsp; Talons Eu42 À D' Talons Femme À Sauvages À Sandales Vert Pièces Sandales Femmes Talons Hauts nbsp;Été Travailleur Parti Bureau pour Femmes Sandales Sandales Les Deux Fine = 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 à :

À Bureau nbsp; Parti Sandales Sandales pour Sandales Sauvages D' Vert Travailleur Pièces Talons nbsp; pour Les Les À Talons Talons Hauts nbsp;Été Eu42 À Deux Femmes Tempérament Femmes Sandales Hauts Femme Fine 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 Femmes Travailleur Hauts Talons À Sandales À À Les Tempérament Femmes pour Vert Deux pour nbsp; Parti Sandales Hauts Les nbsp;Été Fine Sandales Femme Sauvages Sandales Eu42 Bureau Talons Pièces D' Talons nbsp; 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.