Booléen Java

Le mot "booléen" dans le contexte du langage Java peut être utilisé dans des sens différents, bien que très liés. Il pourrait être:

• type primitif booléen ou variable booléenne de ce type
• Classe booléenne Java ou objet wrapper booléen
• Expression booléenne , valeur booléenne, condition
• Opérateurs booléens Java

Dans cet article, nous allons couvrir toutes ces options et expliquer quels concepts sous-tendent les expressions booléennes .

Qu'est-ce qu'un booléen au sens général

Le concept d' expression booléenne est venu des mathématiques, ou plutôt de la logique mathématique. Une expression booléenne en algèbre propositionnelle est une expression qui peut être dite vraie ou fausse. Par exemple: En même temps, "2" ou "neige" ne sont pas des expressions booléennes .

Type de données primitif booléen Java et variables booléennes

En parlant d'un booléen en Java, il s'agit d'abord très probablement d'un type de données primitif booléen et de variables booléennes de ce type. Comme vous l'avez probablement déjà deviné, les variables de ce type ne peuvent prendre que deux valeurs, true et false. Java a des restrictions assez strictes : un booléen en Java ne peut être converti en aucun autre type de données, et vice versa. En particulier, booléen en Java n'est pas un type intégral et les valeurs entières ne peuvent pas être utilisées à la place des booléens. Voici un exemple de définition directe d'un type booléen :

boolean myBoolean; //boolean variable
myBoolean = false; 
boolean myBoolean1 = true; //another boolean variable

Nous avons ici 2 variables booléennes . Écrivons un petit programme avec un exemple d'utilisation d'un type booléen :

//boolean variable example
public class BoolTest {

   public static void main(String[] args) {
       boolean myBoolean = false;
       System.out.println(myBoolean);
   }
}

Ce programme imprime "faux" sur la console. Soit dit en passant, une variable booléenne est définie sur false par défaut, mais Java ne vous permet pas de travailler avec des variables locales non initialisées.

Expressions booléennes en Java

En plus d'initialiser explicitement une variable booléenne à true ou false, le type de données booléen est implicitement utilisé à de nombreux endroits. Tout comme le résultat de toute addition de nombres sera un nombre, le résultat de toute comparaison sera vrai ou faux, c'est-à-dire qu'il sera de type booléen . Cela signifie qu'en plus de spécifier directement une valeur booléenne via l' instruction d'affectation de variable booléenne , les valeurs booléennes résultent de diverses comparaisons, telles que 5 > 2 , et sont principalement utilisées dans les instructions conditionnelles et en boucle. Voici un exemple d'une telle utilisation de type booléen :

public class BoolTest {

   public static void main(String[] args) {
       boolean myBoolean = false;
       int a = 5;
       int b = 7;
       System.out.println(a < b);
       System.out.println(0 > 7);
       System.out.println(myBoolean == false);
   }
}

La sortie est : Dans le cas de a < b , l' opérateur < compare l'expression de gauche avec l'expression de droite. Nous avons affiché le résultat de la comparaison sur l'écran. Puisque 5 < 7 (l'instruction est vraie), la valeur true sera imprimée sur la console. Dans le second cas, on affiche une comparaison directe de zéro et sept, et dans le troisième, on demande si la valeur de la variable myBoolean est fausse. Puisque c'est le cas, nous sortons la valeur true . En fait, pour construire des expressions booléennes en Java, nous pouvons utiliser n'importe quel opérateur de comparaison :

Où les valeurs booléennes sont utilisées

Les valeurs booléennes et les expressions conditionnelles sont très souvent utilisées dans les conditions des instructions de branchement, des opérateurs ternaires et des boucles. En fait, leur utilisation repose sur la vérification de certaines expressions booléennes . Par exemple:

public class BoolTest2 {
       public static void main(String[] args) {
           int i = 0;
           while (i <= 10)
           {
               System.out.println(i);
               i++;
           }         
      }
}

Ce programme imprime une séquence d'entiers et les incrémente de un tant que la condition entre parenthèses après le moment est remplie. Autrement dit, tant que l'expression i <=10 est vraie.

Opérateurs booléens Java. Construire des expressions booléennes avec des opérateurs booléens

Les opérations logiques (ou booléennes) suivantes sont disponibles en Java :

• Négation logique, c'est aussi NON ou inversion. En Java, désigné par le symbole ! avant l'expression.

• Et logique, c'est aussi ET ou conjonction. Désigné par le symbole & entre les deux expressions auxquelles il s'applique.

• Logique ou en Java, c'est aussi OU, c'est aussi disjonction. En Java, désigné par le symbole | entre deux expressions.

• Exclusif ou, XOR, disjonction stricte. En Java, il est désigné par le symbole ^ entre deux expressions.

• En Java, les opérateurs logiques incluent le ou conditionnel, noté || , ainsi que le conditionnel and, && .

Jetons un coup d'œil au tableau avec une brève description de chacun des opérateurs booléens Java, et ci-dessous, nous les décrirons plus en détail et donnerons des exemples de code. Par « opérandes » dans le tableau, nous entendons l'expression logique ou les variables auxquelles s'applique l'opérateur.

a | b == true

Notez qu'en Java, les opérateurs & , | et ^ s'appliquent également aux nombres entiers. Dans ce cas, ils fonctionnent un peu différemment et sont appelés opérateurs logiques au niveau du bit (ou au niveau du bit). Prenons un exemple et affichons plusieurs expressions logiques composées à l'aide d'opérateurs logiques.

public class BoolTest2 {
   public static void main(String[] args) {
   int a = 5;
   int b = 7;
   boolean myBool1 = true;
   boolean myBool2 = false;
       System.out.println(myBool1&myBool2);
       System.out.println(myBool1|myBool2);
       System.out.println(!myBool1);
       System.out.println((a > b) & !myBool1 | myBool2);
   }
}

Voici la sortie : En fait, vous pouvez faire des constructions logiques très complexes en utilisant des opérateurs logiques. Par exemple Si toutes les variables sont initialisées, de telles constructions fonctionneront. Cependant, il ne faut pas en abuser, ils rendent difficile la lecture du code. Néanmoins, il est très utile de traiter de telles constructions logiques. Essayez de créer des expressions logiques avec d'autres opérateurs logiques donnés dans le tableau.

Priorité des opérations logiques

Comme en mathématiques, en programmation, les opérateurs ont un ordre d'exécution spécifique s'ils apparaissent dans la même expression. Les opérateurs unaires ont des avantages sur les binaires, et la multiplication (même logique) sur l'addition. Voici les opérateurs logiques placés dans la liste des sujets plus haut, plus leur priorité est élevée :

• !

• &

• ^

• |

• &&

• ||

Enveloppe booléenne Java

En Java, chaque type primitif a un "frère", une classe wrapper ( Wrapper ). Un wrapper est une classe spéciale qui stocke la valeur d'une primitive à l'intérieur. Cependant, il s'agit d'une classe, vous pouvez donc en créer des instances (objets). Ces objets stockent les valeurs nécessaires des primitives à l'intérieur, alors qu'ils seront de vrais objets. Le type primitif booléen Java a une classe wrapper booléenne Java (avec un B majuscule). Les objets Boolean Class sont créés comme n'importe quel autre :

Boolean b = new Boolean(false);

La classe booléenne Java a des méthodes utiles. L'une des plus intéressantes est la méthode parseBoolean . La méthode static boolean parseBoolean(String s) analyse l'argument de chaîne comme un booléen. Le booléen renvoyé représente la valeur true si l'argument de la chaîne n'est pas nul et est égal, sans tenir compte de la casse, à la chaîne "true". Sinon, il renvoie false .

exemple de méthode parseBoolean

public class BoolTest2 {

        public static void main(String[] args)
        {
            System.out.println(Boolean.parseBoolean("True"));
            System.out.println(Boolean.parseBoolean("TRuE"));
            System.out.println(Boolean.parseBoolean("False"));
            System.out.println(Boolean.parseBoolean("here"));

        }
    }

La sortie est : Pour renforcer ce que vous avez appris, nous vous suggérons de regarder une leçon vidéo de notre cours Java