Guide du débutant sur les opérateurs logiques et relationnels en Java

Les opérateurs sont des symboles utilisés pour effectuer des opérations sur des valeurs, des variables ou des instructions. Les expressions sur lesquelles ils effectuent ces actions sont appelées opérandes. Les opérations renvoient un résultat booléen (vrai ou faux) pour les opérateurs relationnels, d'égalité et logiques.

Le nombre d'opérandes qu'un opérateur prend détermine son type. Un opérateur qui prend un opérande est appelé « unaire ». Un opérateur qui prend deux opérandes est appelé 'binaire'.

Lisez la suite pour savoir comment utiliser les opérateurs logiques et relationnels en Java. Mieux encore, la plupart des langages de programmation utilisent les mêmes opérateurs, vous pouvez donc appliquer ces connaissances ailleurs.

Opérateurs logiques

Ils sont utilisés pour construire des instructions logiques lors de la programmation. Il existe six opérateurs logiques en Java. Le tableau ci-dessous les résume.

Opérateur	Nom	Taper
\|	OU logique booléen	Binaire
&	ET logique booléen	Binaire
^	OU exclusif logique booléen	Binaire
\|\|	OU conditionnel	Binaire
&&	ET conditionnel	Binaire
!	NON logique	Unaire

Si vous voulez vérifier si une ou les deux conditions sont vraies, utilisez cet opérateur. Une condition est une expression qui peut être vraie ou fausse.

OU logique booléen inclusif (|)

Le OU logique vérifie si les deux opérandes sont vrais avant d'évaluer l'expression.

if ( dob <2005 | height <= 5){  
money++;  
}

L'exemple ci-dessus donnera à quelqu'un plus d'argent si sa date de naissance (dn) est inférieure à 2005 ou si sa taille est inférieure ou égale à 5 pieds.

ET logique booléen (&)

Cet opérateur est utilisé pour vérifier si les deux conditions sont vraies avant de prendre un certain chemin d'exécution dans le programme. Il vérifie d'abord si les deux conditions sont vraies avant d'évaluer l'ensemble de l'expression.

En relation: Comment valider des chaînes à l'aide de méthodes booléennes en Python

OU logique exclusif booléen (^)

Si vous voulez vérifier si l'une des conditions est vraie, mais pas les deux, alors c'est l'opérateur à utiliser. La table de vérité ci-dessous résume les résultats que vous verrez lorsque vous l'utiliserez.

expression1	expression2	expression1 ^ expression2
faux	faux	faux
faux	vrai	vrai
vrai	faux	vrai
vrai	vrai	faux

ET conditionnel booléen (&&)

Cet opérateur est similaire au ET logique. La différence est qu'il vérifie d'abord si la condition de gauche est vraie avant de passer à celle de droite.

Si la partie gauche est fausse, l'exécution s'arrête immédiatement. Sinon, l'évaluation de la partie droite se poursuivra. Cette caractéristique est connue sous le nom d'évaluation de court-circuit.

Consultez la table de vérité ci-dessous pour ancrer votre compréhension de cet opérateur.

expression1	expression2	expression1 && expression2
faux	faux	faux
faux	vrai	faux
vrai	faux	faux
vrai	vrai	vrai

OU conditionnel (||)

Si l'une des conditions est fausse, l'exécution passera à la partie suivante du programme. En d'autres termes, les deux conditions doivent être vraies.

Cet opérateur est similaire au OU Logique. Il vérifie également si l'une ou les deux conditions sont vraies avant d'exécuter un certain code.

Semblable au ET conditionnel, le OU logique utilise également une évaluation de court-circuit. Il vérifie d'abord si l'opérande de gauche est vrai avant d'évaluer celui de droite.

En rapport: Qu'est-ce qu'un constructeur en Java et comment l'utilisez-vous ?

comment ma vie sait-elle qui me cherche

Si la condition de gauche s'avère vraie, alors il n'est pas nécessaire de vérifier celle de droite. Sinon, l'évaluation à droite se poursuivra.

NON logique (!)

Cet opérateur est utilisé pour annuler une condition. Il renverse simplement le sens de ce sur quoi il opère.

if(!(x>5)){  
// statements  
}

L'instruction ci-dessus signifie que si 'x est supérieur à 5' n'est PAS vrai, alors exécutez les instructions à l'intérieur du si .

Notez l'utilisation de parenthèses rondes avec l'expression (x>5). Si vous n'incluez pas ces crochets lors de l'écriture de votre programme, vous obtiendrez une erreur de compilation. La raison en est que ! est un opérateur unaire qui agit sur une condition. Sans les crochets, le compilateur l'interpréterait comme l'opérateur agissant sur le x, pas x>5.

L'inclusion de crochets n'est pas seulement pour permettre au compilateur d'interpréter correctement une expression. Ils peuvent également être utilisés comme un moyen pour le programmeur de mieux comprendre des expressions plus complexes. Regardez l'exemple ci-dessous :

age >= 7 && height <5

Certaines personnes pourraient avoir du mal à suivre la logique. Par conséquent, certains programmeurs préfèrent ajouter des parenthèses redondantes pour des raisons de lisibilité :

(age >= 7) && (height <5)

Opérateurs relationnels

Ces opérateurs sont utilisés pour comparer des relations simples entre des opérandes.

Opérateur	Nom
>	Plus grand que
<	Moins que
> =	Plus grand ou égal à
<=	Inférieur ou égal à

Les opérateurs relationnels sont assez faciles à comprendre car ils ont tous la même signification que les opérateurs algébriques habituels que vous connaissez déjà. C'est-à-dire, > et < ont la même signification que vous connaissez déjà que celle donnée dans le tableau ci-dessus.

if( x <= 7 ){  
x++;  
}

Ce qui précède si L'instruction vérifie si x est inférieur ou égal à 7. Si vrai, alors les instructions entre crochets s'exécutent, sinon elles ne le font pas.

Le moment serait venu de mentionner les opérateurs d'égalité. Il n'y en a que deux ( égal à, == et !=, différent de ). Comme leur nom l'indique, ils sont utilisés pour tester l'égalité entre deux opérandes.

En rapport: Comment créer et effectuer des opérations sur des tableaux en Java

L'opérateur d'égalité (==) ne doit pas être confondu avec l'opérateur d'affectation (=). Les programmeurs débutants aiment mélanger les deux. C'est raisonnable puisqu'en algèbre le symbole (=) est utilisé pour exprimer l'égalité. Ce n'est pas juste dans la programmation, cependant.

L'opérateur d'affectation (=) affecte une valeur à une variable tandis que l'opérateur d'égalité (==) teste l'égalité. Voir l'exemple ci-dessous pour comprendre la différence :

if(x=5){  
// statements  
}

Le code ci-dessus s'exécutera toujours, que x soit réellement égal à 5. Pendant ce temps, le code ci-dessous ne s'exécutera que si x est égal à 5. Par conséquent, il est important de ne pas confondre les deux.

if(x==5){  
// statements  
}

Les deux opérateurs d'égalité mentionnés ont le même niveau de priorité, bien qu'inférieur à celui des opérateurs relationnels.

Les opérateurs relationnels ont également le même niveau de priorité. L'exécution de ces opérateurs commence de gauche à droite.

Considérations supplémentaires sur les opérateurs Java

Vous devez avoir observé qu'il y a un espace entre certains opérateurs et leurs opérandes dans certains des exemples alors que dans d'autres, il n'y en a pas.

L'absence/la présence de cet espace ne devrait pas vous inquiéter. Le compilateur l'ignorera. Par conséquent, les expressions suivantes signifient la même chose :

Y>=7 // no whitespace  
Y >= 7 // with whitespace

Les opérateurs relationnels sont généralement utilisés pour exprimer des conditions simples. Pour combiner des conditions simples en conditions plus complexes, vous devrez utiliser des opérateurs logiques. Les opérateurs logiques peuvent tester plusieurs conditions, contrairement aux opérateurs relationnels qui ne testent qu'une seule condition.

Il est également important de noter que les opérateurs logiques ( |, &, ^) peuvent être des opérateurs au niveau du bit lorsqu'ils ont des opérandes entiers. Lorsqu'ils sont utilisés comme opérateurs au niveau du bit, ils fonctionneront sur les bits de leurs opérandes.

Avec cette connaissance des opérateurs, vous devriez maintenant vous préparer à apprendre les classes Java.

Partager Partager Tweeter E-mail Apprenez à créer des classes en Java

Si vous apprenez à programmer en Java, vous devrez savoir créer des classes.

Lire la suite Rubriques connexes

La programmation
Java
Tutoriels de codage

A propos de l'auteur Jérôme Davidson(22 articles publiés)

Jérôme est rédacteur chez MakeUseOf. Il couvre des articles sur la programmation et Linux. Il est également un passionné de crypto et garde toujours un œil sur l'industrie de la crypto.

Plus de Jerome Davidson

Abonnez-vous à notre newsletter

Rejoignez notre newsletter pour des conseils techniques, des critiques, des ebooks gratuits et des offres exclusives !

Cliquez ici pour vous abonner