Utilisation de l'opérateur Not dans des conditions If en Java

1. Introduction

Dans les instructions if-else de Java, nous pouvons effectuer une certaine action lorsqu'une expression est vraie , et une alternative lorsqu'elle est fausse . Dans ce didacticiel, nous allons apprendre comment inverser la logique à l'aide de l' opérateur not .

2. La déclaration if-else

Commençons par une simple instruction if-else :

boolean isValid = true; if (isValid) { System.out.println("Valid"); } else { System.out.println("Invalid"); }

Et si notre programme n'avait besoin que de gérer le cas négatif? Comment réécrire l'exemple ci-dessus?

Une option consiste simplement à supprimer le code dans le bloc if :

boolean isValid = true; if (isValid) { } else { System.out.println("Invalid"); }

Cependant, un bloc if vide semble être du code incomplet, et semble être un moyen fastidieux de gérer uniquement la condition négative. Nous pourrions plutôt essayer de tester si notre expression logique est évaluée à false :

boolean isValid = true; if (isValid == false) { System.out.println("Invalid"); }

La version ci-dessus est relativement facile à lire, bien qu'elle puisse être plus difficile à faire si l'expression logique était plus complexe. Java a une alternative pour nous, cependant, sous la forme de l' opérateur not :

boolean isValid = true; if (!isValid) { System.out.println("Invalid"); }

3. L' opérateur not

L' opérateur not est un opérateur logique, représenté en Java par le ! symbole. C'est un opérateur unaire qui prend une valeur booléenne comme opérande. L' opérateur not fonctionne en inversant (ou en annulant) la valeur de son opérande .

3.1. Application de l' opérateur not à une valeur booléenne

Lorsqu'il est appliqué à une valeur booléenne, l' opérateur not transforme true en false et false en true .

Par exemple:

System.out.println(!true); // prints false System.out.println(!false); // prints true System.out.println(!!false); // prints false

3.2. Application de l' opérateur not à une expression booléenne

Puisque not est un opérateur unaire, lorsque vous ne voulez pas le résultat d'une expression, vous devez mettre cette expression entre parenthèses pour obtenir la bonne réponse. L'expression entre parenthèses est évaluée en premier, puis l' opérateur not inverse son résultat.

Par exemple:

int count = 2; System.out.println(!(count > 2)); // prints true System.out.println(!(count <= 2)); // prints false
boolean x = true; boolean y = false; System.out.println(!(x && y)); // prints true System.out.println(!(x || y)); // prints false 

Il faut noter que lors de la négation d'une expression, les lois de De Morgan entrent en jeu. En d'autres termes, chaque terme de l'expression est annulé et l'opérateur est inversé. Cela peut nous aider à simplifier les expressions difficiles à lire.

Par exemple:

!(x && y) is same as !x || !y !(x || y) is same as !x && !y !(a <3 && b == 10) is same as a>= 3 || b != 10 

4. Quelques pièges courants

L'utilisation de l' opérateur not peut parfois compromettre la lisibilité de notre code. Les négatifs peuvent être plus difficiles à comprendre que les positifs. Regardons quelques exemples.

4.1. Double négatifs

Étant donné que l' opérateur not est un opérateur de négation, son utilisation avec des variables ou des fonctions qui ont un nom négatif peut entraîner un code difficile à lire. Ceci est similaire aux langues naturelles, où les doubles négatifs sont souvent considérés comme difficiles à comprendre.

Par exemple:

if (product.isActive()) {...}

lit mieux que

if (!product.isNotActive()) {...}

Bien que notre API ne fournisse pas de méthode isActive , nous pouvons en créer une pour faciliter la lisibilité.

4.2. Conditions complexes

L' opérateur not peut parfois rendre une expression déjà complexe encore plus difficile à lire et à comprendre. Lorsque cela se produit, nous pouvons simplifier le code en inversant la condition ou en extrayant des méthodes. Regardons quelques exemples de conditions rendues complexes par l' opérateur not et comment nous pouvons les simplifier en inversant la condition:

if (!true) // Complex if (false) // Simplified if (!myDate.onOrAfter(anotherDate)) // Complex if (myDate.before(anotherDate)) // Simplified if (!(a >= b)) // Complex if (a = 10 || total >= 1000)) // Complex if (count < 10 && total < 1000) // Simplified

5. Conclusion

Dans cet article, nous avons abordé l' opérateur not et comment il peut être utilisé avec des valeurs booléennes, des expressions et dans des instructions if-else .

Nous avons également examiné quelques pièges courants, causés par l'écriture d'expressions dans leur inverse et comment les résoudre.

Comme toujours, le code source des exemples utilisés dans cet article est disponible à l'adresse over sur GitHub.