Opérateurs logiques

« Salut Amigo ! »

"Maintenant, nous allons avoir une petite leçon sur les opérateurs logiques."

« Quels opérateurs logiques connaissez-vous ? »

— OU (||), ET (&&), NON (!)

« Ouais. Bon travail. Et tu te souviens comment ils fonctionnent ?

"Oui."

"OU renvoie vrai lorsqu'au moins un opérande est vrai."

"ET renvoie vrai lorsque les deux opérandes sont vrais."

"NOT change vrai en faux et faux en vrai."

"C'est vrai. Et dans quel ordre les opérateurs sont-ils évalués dans cette expression ?"

boolean a = true;
boolean b = false;
boolean c = true;

boolean result = a && b || !c && b || !a;

"C'est très simple."

"D'abord, PAS (!), puis ET (&&), puis OU (||) à la toute fin."

Si nous ajoutions des parenthèses, nous obtiendrions :

boolean a = true;
boolean b = false;
boolean c = true;

boolean result = (a && b) || ((!c) && b) || (!a);

"C'est tout à fait correct, bravo. Et quel est le résultat ?"

— 1) (a && b) == (vrai && faux) == faux

2) ((!c) && b) == (faux && faux) == faux

3) (!a) == faux

4) faux || faux || faux == faux

"Le résultat est faux."

"Il semble que vous connaissiez parfaitement le sujet. Alors je vais vous dire quelques petits secrets."

"Tout d'abord, les expressions logiques sont évaluées de gauche à droite."

"Deuxièmement, l'évaluation en court-circuit est utilisée ici (les calculs ne sont effectués que si nécessaire). Si le résultat final est déjà connu à partir de l'évaluation d'une partie de l'expression, le reste de l'expression n'est pas évalué."

boolean result = (true && false) || (true && true) || (true && false);

"Cette expression est divisée en trois parties séparées par l'opérateur OR (||)."

"Si au moins une partie est vraie, alors la réponse est vraie et rien d'autre n'a besoin d'être pris en compte. En conséquence, l'expression est évaluée comme ceci :"

1)  Évaluez la première partie :  (true && false) == false

2)  Évaluez la deuxième partie :  (true && true) == true

3) Nous n'évaluons pas la troisième partie, car il est déjà clair que la réponse sera vraie .

"Cette approche est également appelée évaluation paresseuse."

« OK. Et qu'est-ce qu'il y a de si spécial ? »

"Rien - jusqu'à ce que vous commenciez à appeler des méthodes à l'intérieur de l'expression. Si une partie de l'expression est ignorée, les méthodes de la partie ignorée ne seront pas appelées."

"Mais cette approche est devenue très courante. Voici pourquoi :"

Job job = null;

if (job != null && job.isDone())
{
…
}

"Si job est null lorsque l'expression est évaluée, alors l'appel job.isDone() n'aura pas lieu !"

"En effet, la première partie de l'expression est fausse, qui est suivie de ET (&&). Ainsi, l'expression entière sera connue comme étant fausse, et la deuxième partie ne sera pas nécessaire."

« Exactement. C'est une bonne technique, non ?

"Ouais."