1.4 Opérateurs et expressions

La valeur d'une expression dépend des valeurs des sous-expressions et de l'opérateur qui les combine. Les sous-expressions d'une expression sont toujours évaluées de gauche à droite. Cette section va passer en revue les différentes catégories d'opérateurs.

1.4.0.0.1 Expressions logiques

Java dispose d'un type booléen, boolean, dont les valeurs sont true et false. Ce type n'est un sous-type ou sur-type d'aucun autre type primitif : en particulier, on ne peut pas convertir un entier en booléen ni un booléen en entier.

Les expressions logiques sont formées à partir des expressions relationnelles à l'aide des opérateurs logiques.

Les opérateurs relationnels sont : <, <=, >, >=, == (égalité), != (non-égalité). La valeur d'une expression relationnelle est un booléen : par exemple, la valeur de 1 == 2 est false (faux), celle de 2 == 2 est true (vrai).

Les opérateurs logiques sont la négation !, le « et » && et le « ou » ||. Par exemple, le « ou exclusif » peut être défini ainsi à l'aide de ces opérateurs :

  static boolean xor(boolean p, boolean q) {
    return p && !q || !p && q;
  }

L'analyse syntaxique d'une expression est précisée par des règles de précédence, que l'on ne peut ignorer que si les expressions sont complètement parenthésées, ce qui est une contrainte souvent excessive : sans ces règles, l'expression logique

p && !q || !p && q

devrait être écrite

(p && (!q))|| ((!p) && q).

Selon les règles de précédence, c'est ! qui a la plus forte précédence, puis && et enfin ||.

1.4.0.0.2 Évaluation séquentielle

Les deux opérateurs logiques binaires ont la particularité d'être séquentiels, c'est-à-dire de donner lieu à une évaluation de gauche à droite, la sous-expression de droite n'étant pas toujours évaluée :

• $A$ && $B$ est faux si $A$ est faux, et vrai si $A$ et $B$ sont vrais : $B$ n'est pas évalué si $A$ est faux
• $A$ || $B$ est vrai si $A$ est vrai, et faux si $A$ et $B$ sont faux : $B$ n'est pas évalué si $A$ est vrai

Ce comportement permet d'écrire des tests de la forme suivante sans provoquer d'erreur :

    if (x != 0 && 1/x < epsilon) { ... }
    if (i > N || t[i] > A) { ... }          // t de taille N

Une autre expression dont l'évaluation est séquentielle est l'expression conditionnelle : l'évaluation de $A$ ? $B$ : $C$ commence par évaluer $A$ ; si sa valeur est vraie, alors $B$ est évalué, sinon $C$ est évalué. Par exemple, la fonction valeur absolue peut être définie ainsi :

  static double abs(double x) {
    return x >= 0 ? x : -x;
  }

L'opérateur conditionnel ayant la plus faible précédence, il n'est pas nécessaire de placer ses trois sous-expressions entre parenthèses.

1.4.0.0.3 Expressions arithmétiques

Ces expressions sont formées à partir des opérateurs arithmétiques : les opérateurs additifs +, -, les opérateurs multiplicatifs *, / et % (modulo) et les opérateurs unaires + et -.

Conformément à l'usage courant, on préfère écrire l'expression 2*x/3 - 5*y plutôt que ((2*x)/3) - (5*y) ; sans règle de précédence, l'expression non parenthésée pourrait tout aussi bien être analysée comme (2*x)/((3-5)*y), qui n'a sûrement pas la même signification. En termes de précédence, les opérateurs unaires (+, -) sont les plus forts, puis viennent les multiplicatifs (*, /, %) et les additifs (+, -). Par exemple, -1+3 est analysée comme (-1) + 3, et 2*x+3*y comme (2*x) + (3*y). Les opérateurs binaires sont parenthésés par la gauche (en anglais, left associative) ; par exemple, x/2*3 est analysée comme (x/2)*3, et x-y-z comme (x-y)-z (s'ils étaient parenthésés par la droite, ces expressions seraient analysées respectivement comme x/(2*3) et comme x-(y-z)). Les opérateurs unaires sont parenthésés par la droite : par exemple, --x est analysée comme -(-x) et non comme (--)x.

Un extrait du tableau des précédences pour les opérateurs arithmétiques, logiques, conditionnels, par ordre de précédence décroissante figure sur le tableau suivant. On retiendra l'ordre : opérateurs arithmétiques, opérateurs de comparaison, opérateurs logiques, qui permet d'écrire sans parenthèse l'expression logique

      x+y>z || x<0 && y<0 
      // analysée en ((x+y)>z) || ((x<0) && (y<0))

opérateurs	parenthésés
! + $_{\mathsf{un}}$ - $_{\mathsf{un}}$	par la droite
* / %	par la gauche
+ -	par la gauche
< <= > >=	par la gauche
== !=	par la gauche
&&	par la gauche
||	par la gauche
? :	par la droite

1.4.0.0.4 Conversions arithmétiques

L'évaluation d'une expression arithmétique additive ou multiplicative comporte une phase de conversion. Quand les opérandes d'une opération ne sont pas de même type (par exemple un int et un float), il y a conversion implicite de l'un d'eux dans le type de l'autre ; par exemple, int + float est converti en float + float. Cette conversion implicite est une promotion, elle se fait toujours de sous-type vers sur-type : de int vers float, de float vers double. Plus exactement :

• si l'un des deux opérandes est de type double, l'autre est converti en double et le résultat est un double ;
• sinon, si l'un des opérandes est de type float, l'autre est converti en float et le résultat est un float ;
• sinon, si l'un des opérandes est de type long, l'autre est converti en long et le résultat est un long ;
• sinon (les types des opérandes sont byte, short ou char), les deux opérandes sont convertis en int et le résultat est un int.

L'évaluation des opérations unaires + et - comporte aussi une promotion de leur opérande en int si son type est byte, short ou char. Par conséquent, dès qu'une expression comporte une opération arithmétique, son type ne peut pas être byte, short ou char.