Accès rapide :
La vidéo
Utilisation du type boolean
Les opérateurs logiques
Cette vidéo vous montre comment utiliser le type booléen en Java. Un comparatif avec la syntaxe C y est proposé.
Le type booléen est un type qui définit deux états : l'état vrai et l'état faux. Les mots clés associés sont, naturellement, boolean
,
true
(l'état vrai) et false
(l'état faux).
Certains langages de programmation, dont le langage C, n'ont pas défini de type booléen et proposent, à la place,
d'utiliser le type int
en considérant que 0
est associé à l'état faux et que toute autre valeur sera associée à l'état vrai.
Dans ces langages, il est courant de trouver des boucles infinies introduites par le code suivant : while( 1 ) { /* du code */ }
.
Comme 1
est toujours vrai, le while
(boucle « tant que ») tournera indéfiniment.
Bien entendu, cette possibilité n'est pas offerte en Java et pour réaliser une boucle infinie, il faudra utiliser le code suivant.
1 2 3 4 5 6 7 8 9 10 11 |
public class Demo { public static void main( String [] args ) { while ( true ) { // Do something } } } |
Un certain nombre d'opérateurs calculent des résultats booléens : c'est, par exemple, le cas des opérateurs de comparaison (==
,
!=
, <
, <=
, ...). De même, certaines instructions attendent des expressions booléennes : l'instruction
if
utilise une condition booléenne pour exécuter ou non un traitement. C'est aussi le cas de l'instruction while
qui
exécutera une boucle tant que la condition booléenne associée sera vraie. Voici un petit exemple :
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 |
public class Demo { public static void main( String [] args ) { boolean debug = true; System.out.println( "Normal display" ); if ( debug ) { System.out.println( "Debug display" ) ; } int i =10; while( i < 0 ) { System.out.println( "i == " + i ); i--; } } } |
Les opérateurs logiques travaillent sur des opérandes booléens. Il existe trois opérateurs logiques.
L'opérateur &&
: il permet de réaliser un « ET » logique. Il faut noter que si l'opérande de gauche est évalué
à false
, alors le second opérande (à droite de l'opérateur) ne sera pas évalué et l'opérateur renverra false
.
L'opérateur ||
: il permet de réaliser un « OU » logique. Il faut noter que si l'opérande de gauche est évalué
à true
, alors le second opérande (à droite de l'opérateur) ne sera pas évalué et l'opérateur renverra true
.
L'opérateur !
: il permet de réaliser un « NOT » logique.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 |
public class Demo { public static void main(String[] args) { boolean state1 = true; System.out.println( "state1 == " + state1 ); boolean state2 = false; System.out.println( "state2 == " + state2 ); // --- Opérateurs booléens : && (and) || (or) ! (not) --- if ( state1 && state2 ) { System.out.println( "Les deux variables sont initialisées à true" ); } if ( state1 || state2 ) { System.out.println( "L'une des deux variables est initialisée à true" ); } if ( state1 == false ) { // if ( state1 == false ) { System.out.println( "state1 est initialisée à false"); } if ( ! state2 ) { // if ( state2 == false ) { System.out.println( "state2 est initialisée à false"); } } } |
Afin, de tester la non évaluation de l'opérande de droite d'un &&
ou d'un ||
, je vous propose de regarder ce
programme.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 |
public class Demo { public static void main(String[] args) { String str = null; double randomValue = Math.random(); // valeur aléatoire entre [0..1[ if ( randomValue > 0.33 ) { if ( randomValue > 0.66 ) { str = "Une chance sur trois"; } else { str = ""; } } boolean leftOperand = str == null; boolean rightOperand = str.trim().equals( "" ); if ( leftOperand || rightOperand ) { System.out.println( "str cannot be null or empty" ); } else { System.out.println( "Ok" ); } } } |
Le programme peut planter, car si la variable str
est nulle, alors elle ne contiendra pas d'objet (d'instance) de chaîne de caractères.
Du coup, la ligne 16 produira l'erreur affichée ci-dessous, en cherchant à invoquer une méthode sur un objet que n'existe pas.
$> java Demo Exception in thread "main" java.lang.NullPointerException at Demo.main(Demo.java:16) $>
Du coup, une solution pour faire correctement fonctionner ce code pourrait être de placer le code des expressions associées aux variables
leftOperand
et rightOperand
directement au niveau de l'opérateur ||
comme le montre l'exemple ci-dessous.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 |
public class Demo { public static void main(String[] args) { String str = null; double randomValue = Math.random(); // valeur aléatoire entre [0..1[ if ( randomValue > 0.33 ) { if ( randomValue > 0.66 ) { str = "Une chance sur trois"; } else { str = ""; } } if ( str == null || str.trim().equals( "" ) ) { System.out.println( "str cannot be null or empty" ); } else { System.out.println( "Ok" ); } } } |
Améliorations / Corrections
Vous avez des améliorations (ou des corrections) à proposer pour ce document : je vous remerçie par avance de m'en faire part, cela m'aide à améliorer le site.
Emplacement :
Description des améliorations :