Rechercher
 

Le type boolean (booléen)

Manipulation des types flottants Manipulation de caractères



Accès rapide :
   La vidéo
   Utilisation du type boolean
   Les opérateurs logiques

La vidéo

Cette vidéo vous montre comment utiliser le type booléen en Java. Un comparatif avec la syntaxe C y est proposé.


Le type boolean (booléen)

Utilisation du type boolean

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
        }
    
    }

}
Exemple de boucle infinie

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--;
        }
    
    }

}
Booléens et instructions

Les opérateurs logiques

Les opérateurs logiques travaillent sur des opérandes booléens. Il existe trois opérateurs logiques.

 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");
        }

    }

}
Utilisation d'opérateurs logiques

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" );
        }

    }

}
Ce programme peut produire, en ligne 16, une exception de type NullPointerException

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" );
        }

    }

}
Ce programme est sécurisé grâce à l'opérateur &&


Utilisation des opérateurs binaires Manipulation de caractères