Booléens et expressions logiques

     

Java, comme beaucoup d'autres langages, mais contrairement à C, 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 : 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 : <, <=, >, >=, ==, !=. Ces opérateurs retournent un booléen : 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 >> ||. Les deux derniers ont la particularité d'être séquentiels, c'est-à-dire de donner lieu à une évaluation de gauche à droite :  

• 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 des opérateurs && et || est différent de celui des and et or de Pascal qui évaluent toujours leurs deux arguments. Il permet d'écrire des tests de la forme :

    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, présente également en CAML, en C et en C++, mais pas en Pascal ou en Fortran :     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, l'expression

    x >= 0 ? x : -x

a pour valeur la valeur absolue de la valeur de x.

Voici un extrait du tableau des précédences  pour les opérateurs arithmétiques, logiques, conditionnels :

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

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

qui est analysée en :

    ((x+y)>z) || ((x<0) && (y<0))

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. Il suffira d'écrire

    n<=1 ? 1 : fib(n-1) + fib(n-2)

au lieu de

    (n<=1) ? 1 : (fib(n-1) + fib(n-2))

Signalons qu'au type primitif boolean est associée une classe enveloppante  Boolean .