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.

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 (ddn) 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.

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.

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.

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

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 if .

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.

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 que > et < ont la même signification que vous connaissez déjà que celle donnée dans le tableau ci-dessus.

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

L'instruction if ci – dessus 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.

Connexe: 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.