Valeurs logiques

images/whitebelt.png (((booléens))

Le type boolean sert à exprimer des valeurs logiques.

Les littéraux correspondants sont true et false.

boolean auTravail =
       java.time.LocalTime.now().getHour() >= 9
auTravail ==> true

Ici l’expression compliquée java.time.LocalTime.now().getHour() donne l’heure courante (la syntaxe de cette expression sera clarifiée plus tard … Pour le moment l’accepter telle quelle).

>= est un opérateur de comparaison (supérieur ou égal)

Expressions logiques

Les opérateurs rendant des booléens :

opérateur rôle
> supérieur
>= supérieur ou égal
< inférieur
<= inférieur ou égal
== égalité
!= différent de

Connecteurs

On peut créer des expressions qui associent des expressions booléennes au moyen de connecteurs logiques

connecteur rôle
&& ET (AND)
|| OU (OR)
! NON (NOT)
int heure = java.time.LocalTime.now().getHour() ;
//journée continue!
boolean auTravail = (heure > 8) && (heure < 17) ;
// pause à midi!
auTravail = ( (heure > 8) && (heure <12)) ||
                ((heure < 17 ) && (heure > 14)) ;

boolean absent = !auTravail ;

Remarque importante: les expressions utilisant ET et OU logique ont un mode opératoire particulier (dit avec court-circuit):

  • si le premier opérande d’un ET rend false le second opérande n’est pas évalué (ici si l’heure est inférieure à 8 alors la seconde comparaison n’est pas effectuée).
  • si le premier opérande d’un OU rend true le second opérande n’est pas évalué (ici si on est le matin on ne cherche pas à savoir si on est l’après-midi!)

Attention : l'égalité stricte entre valeurs flottantes est à manier avec précaution! C’est dû à la représentation interne des nombres flottants: il peut être prudent d'écrire un code qui exprime une égalité … à un epsilon près (à "peu" près).

//ici résulat d'une expression flottante
// rend un résultat approximatif
jshell> 0.3 == (0.1 + 0.1 + 0.1)
$1 ==> false

Aiguilleur d'évaluation

Cette opération particulière (l’opérateur ternaire : expressionBoolénne ? expressionSiVrai : expressionSinon ) est un aiguilleur d'évaluation: le type retourné doit être cohérent entre les deux expressions résultat à évaluer.

int max = ix > iy ? ix : iy ; // opérateur de test -ternaire-

Remarque: nous verrons plus tard un aiguillage de choix si… alors …sinon qu’il ne faut pas confondre avec cet opérateur ternaire.

--exercice: sur les booléens--

Opérateurs bit à bit

images/brownbelt.png

Il s’agit d’opérations s’effectuant sur les représentations binaire (en Anglais bitwise operations).

Les débutants peuvent sauter ce point qui ne concerne que des opérations de bas niveau.

Donc pour mémoire uniquement (rechercher les explications détaillées sur le WEB):

opérateur rôle sur les bits
& ET (AND)
| OU inclusif (OR)
^ OU exclusif (XOR))
~ Négation (NOT)
<<n décalage à gauche de n positions
>>n décalage à droite de n positions
>>>n décalage à droite sans conservation du signe

On retrouvera avec ces opérateurs l'écriture d’affectations optimisées: &=, |=,… etc. (noter également que quand on utilise des opérateurs & et | avec des booléens on n’exécute pas avec court-circuit).

--exercice: sur les opérations bit à bit--