Java a un type simple qui représente des valeurs logiques appelées booléennes. Sa valeur ne peut être que l'une des deux valeurs suivantes : vrai ou faux. Tout cela ressemble à un Le programme suivant illustre l'utilisation des types booléens :
// Démonstration des valeurs booléennes class BoolTest { public static void main(String args[]) { boolean b = false; System.out.println("b is " + b = true; ("b is " + b); // une valeur booléenne peut contrôler l'instruction if if(b) System.out.println("Ceci est exécuté."); System.out.println("Ceci n'est pas exécuté."); // le résultat d'un opérateur relationnel est une valeur booléenne System.out.println("10 > 9 est " + (10 > 9)); Les résultats de l'exécution de ce programme sont les suivants :
b est faux b est vrai Ceci est exécuté 10 > 9 est vrai.
Il y a 3 choses intéressantes à noter à propos de ce programme. Tout d'abord, vous avez vu que lorsque vous utilisez la méthode println() pour générer une valeur booléenne, elle affiche « vrai » ou « faux ». Deuxièmement, la valeur de la variable booléenne elle-même est suffisante pour contrôler l'instruction if. Il n'est pas nécessaire d'écrire des instructions if comme celle-ci :
si(b == vrai) ...
Troisièmement, le résultat d'un opérateur relationnel (tel que <) est une valeur booléenne. C'est pourquoi l'expression 10>9 affiche « vrai ». De plus, les parenthèses supplémentaires sont ajoutées des deux côtés de l'expression 10>9 car l'opérateur du signe plus "+" a une priorité plus élevée que l'opérateur ">".
La différence entre les opérations logiques et les opérations au niveau du bit sur les types booléens JAVA
En termes de résultats, les résultats des deux opérations sont les mêmes, mais l'opération logique aura un phénomène de « court-circuit », contrairement à l'opération au niveau du bit, et l'opération au niveau du bit a plus de fonctions « XOR » que l'opération logique.
phénomène de court-circuit
class br { static boolean f1() { return false; } static boolean f2() { return true; static boolean f3() { return true }} boolean f_1 = br.f1()&&br.f2()&&br.f3 (); Le résultat est faux. Lorsque f1() est faux, alors le résultat de l'opération && suivante est connu sans qu'il soit nécessaire de l'effectuer. JAVA "court-circuitera" l'opération suivante, améliorant ainsi les performances.
booléen f_2 = br.f2()||br.f1()||br.f3();
Le résultat est vrai De même, f2() est vrai et il n’est pas nécessaire d’effectuer d’autres opérations.
Cela semble très pratique et efficace, mais il présente encore des inconvénients.
booléen f_3 = br.f2()||br.f3()&&br.f1();
Le résultat devient vrai, ce qui devrait être faux. Il s'agit d'une erreur provoquée par un "court-circuit". Si vous souhaitez obtenir la bonne réponse, vous devez ajouter des parenthèses :
f_3=( br.f2()||br.f3())&&br.f1();
Les opérations au niveau du bit fournissent une fonctionnalité XOR que la logique ne propose pas :
booléen f = vrai ^ vrai ;
Résultat f = faux ;