Java Boolean : tout ce qu’il faut savoir sur la valeur logique

Dans le langage de pro­gram­ma­tion, le Java Boolean (« variable booléenne » ou « booléen » en français) est l’un des types de données primitifs. La valeur logique est ini­tia­li­sée lorsqu’il ne doit y avoir que deux valeurs possibles. Dans les cas les plus courants, celles-ci sont true et false. Le booléen Java est ainsi à la base de nom­breuses commandes et actions lors d’une pro­gram­ma­tion.

Qu’est-ce qu’un booléen Java et à quoi sert-il ?

En tra­vail­lant avec un langage de pro­gram­ma­tion, il faut souvent tenir compte de con­di­tions pour les­quelles seuls deux états sont en­vi­sa­geables. Des exemples ma­ni­festes sont les options On et Off, les réponses possibles Oui et Non ainsi que les valeurs true et false (pour vrai et faux). Si vous souhaitez apprendre à pro­gram­mer, vous re­mar­que­rez cer­tai­ne­ment que de nom­breuses étapes de travail reposent sur un principe de base simple qui permet ou empêche, par exemple, l’exécution d’une commande Java selon l’état qui s’applique. Le type de données standard pour ces tâches est le booléen Java.

Une telle valeur booléenne (d’après le ma­thé­ma­ti­cien bri­tan­nique George Boole) est un élément de l’algèbre et décrit une variable pour laquelle seul un certain nombre de valeurs est autorisé. En pro­gram­ma­tion, ce principe est utilisé pour créer des logiques et lier l’exécution d’une ap­pli­ca­tion à une certaine condition. Si cette condition est remplie (si elle est donc vraie), elle est exécutée. Si la condition n’est pas remplie, l’exécution est in­ter­rom­pue.

Comment créer une variable booléenne ?

C’est en principe très simple de créer un booléen Java. La syntaxe prend la forme suivante :

boolean exempleboolean = true; // or false

Ce faisant, vous dé­ter­mi­nez si la valeur doit être vraie ou fausse.

Dans l’exemple de base suivant, vous pouvez constater comment un booléen Java est créé puis affiché. Pour cela, nous dé­fi­nis­sons deux valeurs, dont l’une doit être vraie et l’autre fausse. Cela se présente comme suit :

public class Main {
	public static void main(String[] args) {
		boolean x = true;
		boolean y = false;
		System.out.println(x);
		System.out.println(y);
	}
}

Lorsqu’il est exécuté, il indiquera :

true
false

Exemple de com­bi­nai­son avec une ins­truc­tion if-else

En pratique, il est toutefois probable que le booléen Java soit combiné avec d’autres ins­truc­tions. Vous dé­fi­nis­sez ainsi que le résultat d’une vé­ri­fi­ca­tion doit être une valeur booléenne. Cela fonc­tionne par exemple avec une ins­truc­tion if-else.

public class Main {
	public static void main(String[] args) {
		int x = 5;
		int y = 10;
		boolean x1 = true;
		boolean y1 = false;
		if (y > x) {
			System.out.println("La condition est : " + x1);
		}
		else {
			System.out.println(" La condition est : " +y1);
		}
	}
}

Dans ce cas par­ti­cu­lier, vous obtenez l’in­di­ca­tion suivante :

La condition est : true

Boolean Java : en com­bi­nai­son avec une boucle while

Un autre exemple concret est la boucle while à laquelle peut être associé le booléen Java. Cette boucle est exécutée tant que la valeur est true. Lorsque ce n’est plus le cas, la boucle cesse de s’exécuter. Dans notre exemple, nous ini­tia­li­sons la valeur x à 10 et demandons au système d’exécuter la boucle aussi longtemps que la valeur définie est in­fé­rieure ou égale à 20. La valeur doit être augmentée de 1 à chaque passage. Nous indiquons cela avec l’in­cré­men­ta­tion ++. Voici à quoi cela ressemble dans la pratique :

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

Notre résultat est désormais le suivant :

10
11
12
13
14
15
16
17
18
19
20

Dès que la variable x atteint la valeur 21, la boucle cesse de s’exécuter.

Exemple d’uti­li­sa­tion d’une ex­pres­sion booléenne

Dans de nombreux cas, on utilise toutefois de simples ex­pres­sions boo­léennes plutôt que le booléen Java explicite. Celles-ci ap­pli­quent le même principe mais sont un peu plus courtes et donc plus claires. Un exemple courant est l’opérateur Java <=, déjà utilisé dans l’exemple de code précédent, soit « inférieur ou égal à ». Pour cela, imaginons à présent qu’il y ait un congé canicule dans une école dès que la tem­pé­ra­ture in­té­rieure dépasse 27 degrés pendant un laps de temps donné. Si c’est le cas, les élèves peuvent rentrer chez eux. Si les tem­pé­ra­tures sont in­fé­rieures, les cours ont lieu nor­ma­le­ment. Le code cor­res­pon­dant avec une ex­pres­sion booléenne ressemble à ceci :

public class Main {
	public static void main(String[] args) {
		int temperatureActuelle = 23;
		int temperatureSeuil = 27;
		if (temperatureActuelle <= temperatureSeuil) {
			System.out.println(" Les cours ont lieu comme prévu.");
		} 	else {
			System.out.println(" Les cours n’ont pas lieu.");
		}
	}
}

L’in­di­ca­tion suivante est obtenue :

Les cours ont lieu comme prévu.

268b453ee6bce04d134428183e93f079