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

Les opérateurs sont des icônes servant à effectuer des opérations sur des valeurs, des variables ou des déclarations. Les expressions sur lesquelles ils effectuent ces actions sont appelées opérandes. Les procédures renvoient un résultat booléen (vrai ou incorrect) pour les opérateurs relationnels, d’égalité et également rationnels.

La variété d’opérandes qu’un pilote prend détermine son type. Un pilote qui prend un opérande est appelé « unaire ». Un driver qui prend 2 opérandes est dit « binaire ».

Lisez la suite pour savoir comment vous pouvez utiliser des pilotes rationnels et relationnels en Java. Mieux encore, la plupart des langages de présentation utilisent exactement les mêmes opérateurs, vous pouvez donc appliquer cette compréhension ailleurs.

Opérateurs logiques

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

OperatorNameType
|OU logique booléenBinaire
&&ET logique booléenBinaire
^OU exclusif logique booléenBinaire
&&||OU conditionnelBinaire
& &ET conditionnelBinaire
!NON logiqueUnaire

Si vous souhaitez vérifier si une ou les deux conditions sont vraies, utilisez ensuite ce pilote. Une condition est une expression qui peut être vraie ou fausse.

OU inclusif logique booléen (|)

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

L’exemple ci-dessus donnera certainement à une personne encore plus d’argent si son jour de naissance (ddb) est inférieur à 2005 ou si sa taille est inférieure ou équivalente à 5 pieds.

ET logique booléen (&)

Ce pilote est utilisé pour examiner si les deux problèmes sont vrais 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’expression entière.

OU exclusif logique booléen (^)

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

Voir aussi :  Qu'est-ce que Less CSS et comment l'utiliser ?
expression 1 expression2 expression1 ^ expression2
fauxfauxfaux
fauxvraivrai
vraifauxvrai
vraivraifaux

ET conditionnel booléen (&&& &)

Cet opérateur est similaire au ET rationnel. La différence est qu’il vérifie d’abord si le problème de gauche est vrai avant de passer à l’inspection de celui de droite.

Si le composant de gauche s’avère être faux, après cette implémentation se termine rapidement. Sinon, l’évaluation de la partie idéale se poursuivra certainement. Cet attribut est connu sous le nom d’évaluation de court-circuit.

Consultez le tableau de réalité ci-dessous pour ancrer votre compréhension de ce pilote.

expression 1 expression2 expression1 && & & expression2
fauxfauxfaux
fauxvraifaux
vraifauxfaux
vraivraivrai

OU conditionnel (||)

Si l’une des conditions est incorrecte, l’exécution évitera le composant suivant du programme. Autrement dit, les deux conditions devraient être vraies.

Ce pilote est similaire au OU logique. Il vérifie en outre si l’un ou les deux problèmes sont vrais avant d’implémenter un code particulier.

Semblable au ET conditionnel, le OU logique utilise également l’analyse des courts-circuits. Il vérifie d’abord si l’opérande aile gauche est vrai avant d’évaluer celui de droite.

Si la condition de gauche s’avère vraie, il n’y a alors aucune demande de vérification de celle de droite. Ou bien, l’évaluation à droite continuera certainement.

NON logique (!)

Cet opérateur est utilisé pour nier un problème. Il tourne simplement autour de la signification de ce qu’il opère.

La déclaration over signifie que si « x est supérieur à 5 » n’est PAS réel, alors exécutez les instructions à l’intérieur du si .

Voir aussi :  Comment créer des exceptions personnalisées en Python

Remarquez l’utilisation d’accolades avec l’expression (x>> 5). Si vous n’incluez pas ces accolades lors de la composition de votre programme, vous obtiendrez certainement une erreur de compilation. Le facteur est dû au fait que ! est un pilote unaire qui agit sur une condition. Sans les parenthèses, le compilateur l’interpréterait comme l’opérateur agissant sur le x, et non sur x>> 5.

L’inclusion de crochets n’est pas simplement destinée à permettre au compilateur d’analyser correctement une expression. Ils peuvent également être utilisés comme un moyen pour le développeur de mieux reconnaître des expressions plus complexes. Découvrez l’exemple ci-dessous :

Certaines personnes pourraient avoir du mal à suivre le raisonnement. Par conséquent, certains développeurs aiment ajouter des parenthèses répétitives pour des raisons de lisibilité :

Opérateurs relationnels

Ces pilotes sont utilisés pour contraster les connexions de base entre les opérandes.

Nom de l’opérateur
>>Plus grand que
<Moins que
>>=Supérieur ou équivalent à
< aussi bien que < ont la même définition que vous connaissez déjà que celle donnée dans le tableau ci-dessus.

Ce qui précède si L’instruction vérifie si x est bien inférieur ou égal à 7. Si vrai, alors les instructions à l’intérieur des parenthèses s’exécutent, ou bien elles ne le font pas.

Ce serait certainement le bon moment pour discuter de l’égalité des droits des opérateurs. Il y en a simplement 2 (équivalent à, == et aussi !=, différent de ). Comme leur nom l’indique, ils servent à vérifier l’égalité entre 2 opérandes.

Le pilote d’égalité des droits -LRB-==-RRB- ne doit pas être confondu avec le pilote de travail (=-RRB-. Les développeurs débutants aiment mélanger les deux. C’est raisonnable car en algèbre le symbole (=-RRB- est utilisé pour révéler l’égalité des droits. Ce n’est pas juste dans la programmation, cependant.

Le pilote de travail (=-RRB- attribue une valeur à une variable tandis que l’opérateur d’égalité -LRB-==-RRB- examine l’égalité des droits. Voir l’exemple ci-dessous pour comprendre la distinction :

Le code ci-dessus s’exécutera constamment, que x soit réellement équivalent à 5. En revanche, le code ci-dessous ne s’implémentera que si x est égal à 5. Par conséquent, il est essentiel de ne pas confondre les deux.

Les deux moteurs d’égalité énoncés ont exactement le même degré de priorité, bien qu’inférieur à celui des opérateurs relationnels.

Les opérateurs relationnels ont également le même degré de priorité. L’exécution de ces pilotes commence à partir du droit délégué.

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

Vous auriez dû remarquer qu’il y a un espace entre certains opérateurs et leurs opérandes dans certains exemples alors que dans d’autres, il n’y en a pas.

L’absence/présence de cette pièce ne devrait pas vous inquiéter. Le compilateur l’oubliera certainement. Par conséquent, les expressions suivantes signifient exactement la même chose :

Les opérateurs relationnels sont généralement utilisés pour partager des problèmes de base. Pour intégrer des conditions simples dans des conditions encore plus compliquées, vous devrez utiliser des pilotes intelligents. Les opérateurs logiques peuvent examiner plusieurs problèmes, contrairement aux pilotes relationnels qui vérifient simplement un problème.

Il est également essentiel de garder à l’esprit que les pilotes logiques (|, &&, ^) peuvent être des opérateurs au niveau du bit lorsqu’ils ont des opérandes essentiels. Lorsqu’ils sont utilisés comme opérateurs au niveau du bit, ils fonctionneront certainement sur les petits leurs opérandes.

Avec cette connaissance des pilotes, vous devriez maintenant vous préparer à suivre des cours Java.

Cliquez pour évaluer cet article !
[Total: Moyenne : ]

Laisser un commentaire

Votre adresse e-mail ne sera pas publiée. Les champs obligatoires sont indiqués avec *